http://git-wip-us.apache.org/repos/asf/hive/blob/21a0142f/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 5a35a50..b4a05b2 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -6186,6 +6186,277 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol } +ThriftHiveMetastore_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + this->__isset.tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->tableType))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->success.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) + { + xfer += iprot->readString(this->success[_i891]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); + std::vector<std::string> ::const_iterator _iter892; + for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) + { + xfer += oprot->writeString((*_iter892)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size893; + ::apache::thrift::protocol::TType _etype896; + xfer += iprot->readListBegin(_etype896, _size893); + (*(this->success)).resize(_size893); + uint32_t _i897; + for (_i897 = 0; _i897 < _size893; ++_i897) + { + xfer += iprot->readString((*(this->success))[_i897]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_table_meta_args::~ThriftHiveMetastore_get_table_meta_args() throw() { } @@ -6231,14 +6502,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size887; - ::apache::thrift::protocol::TType _etype890; - xfer += iprot->readListBegin(_etype890, _size887); - this->tbl_types.resize(_size887); - uint32_t _i891; - for (_i891 = 0; _i891 < _size887; ++_i891) + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->tbl_types.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += iprot->readString(this->tbl_types[_i891]); + xfer += iprot->readString(this->tbl_types[_i902]); } xfer += iprot->readListEnd(); } @@ -6275,10 +6546,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size())); - std::vector<std::string> ::const_iterator _iter892; - for (_iter892 = this->tbl_types.begin(); _iter892 != this->tbl_types.end(); ++_iter892) + std::vector<std::string> ::const_iterator _iter903; + for (_iter903 = this->tbl_types.begin(); _iter903 != this->tbl_types.end(); ++_iter903) { - xfer += oprot->writeString((*_iter892)); + xfer += oprot->writeString((*_iter903)); } xfer += oprot->writeListEnd(); } @@ -6310,10 +6581,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size())); - std::vector<std::string> ::const_iterator _iter893; - for (_iter893 = (*(this->tbl_types)).begin(); _iter893 != (*(this->tbl_types)).end(); ++_iter893) + std::vector<std::string> ::const_iterator _iter904; + for (_iter904 = (*(this->tbl_types)).begin(); _iter904 != (*(this->tbl_types)).end(); ++_iter904) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter904)); } xfer += oprot->writeListEnd(); } @@ -6354,14 +6625,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - this->success.resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size905; + ::apache::thrift::protocol::TType _etype908; + xfer += iprot->readListBegin(_etype908, _size905); + this->success.resize(_size905); + uint32_t _i909; + for (_i909 = 0; _i909 < _size905; ++_i909) { - xfer += this->success[_i898].read(iprot); + xfer += this->success[_i909].read(iprot); } xfer += iprot->readListEnd(); } @@ -6400,10 +6671,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<TableMeta> ::const_iterator _iter899; - for (_iter899 = this->success.begin(); _iter899 != this->success.end(); ++_iter899) + std::vector<TableMeta> ::const_iterator _iter910; + for (_iter910 = this->success.begin(); _iter910 != this->success.end(); ++_iter910) { - xfer += (*_iter899).write(oprot); + xfer += (*_iter910).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6448,14 +6719,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size900; - ::apache::thrift::protocol::TType _etype903; - xfer += iprot->readListBegin(_etype903, _size900); - (*(this->success)).resize(_size900); - uint32_t _i904; - for (_i904 = 0; _i904 < _size900; ++_i904) + uint32_t _size911; + ::apache::thrift::protocol::TType _etype914; + xfer += iprot->readListBegin(_etype914, _size911); + (*(this->success)).resize(_size911); + uint32_t _i915; + for (_i915 = 0; _i915 < _size911; ++_i915) { - xfer += (*(this->success))[_i904].read(iprot); + xfer += (*(this->success))[_i915].read(iprot); } xfer += iprot->readListEnd(); } @@ -6593,14 +6864,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size905; - ::apache::thrift::protocol::TType _etype908; - xfer += iprot->readListBegin(_etype908, _size905); - this->success.resize(_size905); - uint32_t _i909; - for (_i909 = 0; _i909 < _size905; ++_i909) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->success.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += iprot->readString(this->success[_i909]); + xfer += iprot->readString(this->success[_i920]); } xfer += iprot->readListEnd(); } @@ -6639,10 +6910,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter910; - for (_iter910 = this->success.begin(); _iter910 != this->success.end(); ++_iter910) + std::vector<std::string> ::const_iterator _iter921; + for (_iter921 = this->success.begin(); _iter921 != this->success.end(); ++_iter921) { - xfer += oprot->writeString((*_iter910)); + xfer += oprot->writeString((*_iter921)); } xfer += oprot->writeListEnd(); } @@ -6687,14 +6958,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size911; - ::apache::thrift::protocol::TType _etype914; - xfer += iprot->readListBegin(_etype914, _size911); - (*(this->success)).resize(_size911); - uint32_t _i915; - for (_i915 = 0; _i915 < _size911; ++_i915) + uint32_t _size922; + ::apache::thrift::protocol::TType _etype925; + xfer += iprot->readListBegin(_etype925, _size922); + (*(this->success)).resize(_size922); + uint32_t _i926; + for (_i926 = 0; _i926 < _size922; ++_i926) { - xfer += iprot->readString((*(this->success))[_i915]); + xfer += iprot->readString((*(this->success))[_i926]); } xfer += iprot->readListEnd(); } @@ -7004,14 +7275,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size916; - ::apache::thrift::protocol::TType _etype919; - xfer += iprot->readListBegin(_etype919, _size916); - this->tbl_names.resize(_size916); - uint32_t _i920; - for (_i920 = 0; _i920 < _size916; ++_i920) + uint32_t _size927; + ::apache::thrift::protocol::TType _etype930; + xfer += iprot->readListBegin(_etype930, _size927); + this->tbl_names.resize(_size927); + uint32_t _i931; + for (_i931 = 0; _i931 < _size927; ++_i931) { - xfer += iprot->readString(this->tbl_names[_i920]); + xfer += iprot->readString(this->tbl_names[_i931]); } xfer += iprot->readListEnd(); } @@ -7044,10 +7315,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size())); - std::vector<std::string> ::const_iterator _iter921; - for (_iter921 = this->tbl_names.begin(); _iter921 != this->tbl_names.end(); ++_iter921) + std::vector<std::string> ::const_iterator _iter932; + for (_iter932 = this->tbl_names.begin(); _iter932 != this->tbl_names.end(); ++_iter932) { - xfer += oprot->writeString((*_iter921)); + xfer += oprot->writeString((*_iter932)); } xfer += oprot->writeListEnd(); } @@ -7075,10 +7346,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size())); - std::vector<std::string> ::const_iterator _iter922; - for (_iter922 = (*(this->tbl_names)).begin(); _iter922 != (*(this->tbl_names)).end(); ++_iter922) + std::vector<std::string> ::const_iterator _iter933; + for (_iter933 = (*(this->tbl_names)).begin(); _iter933 != (*(this->tbl_names)).end(); ++_iter933) { - xfer += oprot->writeString((*_iter922)); + xfer += oprot->writeString((*_iter933)); } xfer += oprot->writeListEnd(); } @@ -7119,14 +7390,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size923; - ::apache::thrift::protocol::TType _etype926; - xfer += iprot->readListBegin(_etype926, _size923); - this->success.resize(_size923); - uint32_t _i927; - for (_i927 = 0; _i927 < _size923; ++_i927) + uint32_t _size934; + ::apache::thrift::protocol::TType _etype937; + xfer += iprot->readListBegin(_etype937, _size934); + this->success.resize(_size934); + uint32_t _i938; + for (_i938 = 0; _i938 < _size934; ++_i938) { - xfer += this->success[_i927].read(iprot); + xfer += this->success[_i938].read(iprot); } xfer += iprot->readListEnd(); } @@ -7181,10 +7452,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Table> ::const_iterator _iter928; - for (_iter928 = this->success.begin(); _iter928 != this->success.end(); ++_iter928) + std::vector<Table> ::const_iterator _iter939; + for (_iter939 = this->success.begin(); _iter939 != this->success.end(); ++_iter939) { - xfer += (*_iter928).write(oprot); + xfer += (*_iter939).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7237,14 +7508,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size929; - ::apache::thrift::protocol::TType _etype932; - xfer += iprot->readListBegin(_etype932, _size929); - (*(this->success)).resize(_size929); - uint32_t _i933; - for (_i933 = 0; _i933 < _size929; ++_i933) + uint32_t _size940; + ::apache::thrift::protocol::TType _etype943; + xfer += iprot->readListBegin(_etype943, _size940); + (*(this->success)).resize(_size940); + uint32_t _i944; + for (_i944 = 0; _i944 < _size940; ++_i944) { - xfer += (*(this->success))[_i933].read(iprot); + xfer += (*(this->success))[_i944].read(iprot); } xfer += iprot->readListEnd(); } @@ -7430,14 +7701,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->success.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size945; + ::apache::thrift::protocol::TType _etype948; + xfer += iprot->readListBegin(_etype948, _size945); + this->success.resize(_size945); + uint32_t _i949; + for (_i949 = 0; _i949 < _size945; ++_i949) { - xfer += iprot->readString(this->success[_i938]); + xfer += iprot->readString(this->success[_i949]); } xfer += iprot->readListEnd(); } @@ -7492,10 +7763,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter939; - for (_iter939 = this->success.begin(); _iter939 != this->success.end(); ++_iter939) + std::vector<std::string> ::const_iterator _iter950; + for (_iter950 = this->success.begin(); _iter950 != this->success.end(); ++_iter950) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter950)); } xfer += oprot->writeListEnd(); } @@ -7548,14 +7819,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size940; - ::apache::thrift::protocol::TType _etype943; - xfer += iprot->readListBegin(_etype943, _size940); - (*(this->success)).resize(_size940); - uint32_t _i944; - for (_i944 = 0; _i944 < _size940; ++_i944) + uint32_t _size951; + ::apache::thrift::protocol::TType _etype954; + xfer += iprot->readListBegin(_etype954, _size951); + (*(this->success)).resize(_size951); + uint32_t _i955; + for (_i955 = 0; _i955 < _size951; ++_i955) { - xfer += iprot->readString((*(this->success))[_i944]); + xfer += iprot->readString((*(this->success))[_i955]); } xfer += iprot->readListEnd(); } @@ -8889,14 +9160,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size945; - ::apache::thrift::protocol::TType _etype948; - xfer += iprot->readListBegin(_etype948, _size945); - this->new_parts.resize(_size945); - uint32_t _i949; - for (_i949 = 0; _i949 < _size945; ++_i949) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->new_parts.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += this->new_parts[_i949].read(iprot); + xfer += this->new_parts[_i960].read(iprot); } xfer += iprot->readListEnd(); } @@ -8925,10 +9196,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter950; - for (_iter950 = this->new_parts.begin(); _iter950 != this->new_parts.end(); ++_iter950) + std::vector<Partition> ::const_iterator _iter961; + for (_iter961 = this->new_parts.begin(); _iter961 != this->new_parts.end(); ++_iter961) { - xfer += (*_iter950).write(oprot); + xfer += (*_iter961).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8952,10 +9223,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter951; - for (_iter951 = (*(this->new_parts)).begin(); _iter951 != (*(this->new_parts)).end(); ++_iter951) + std::vector<Partition> ::const_iterator _iter962; + for (_iter962 = (*(this->new_parts)).begin(); _iter962 != (*(this->new_parts)).end(); ++_iter962) { - xfer += (*_iter951).write(oprot); + xfer += (*_iter962).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9164,14 +9435,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size952; - ::apache::thrift::protocol::TType _etype955; - xfer += iprot->readListBegin(_etype955, _size952); - this->new_parts.resize(_size952); - uint32_t _i956; - for (_i956 = 0; _i956 < _size952; ++_i956) + uint32_t _size963; + ::apache::thrift::protocol::TType _etype966; + xfer += iprot->readListBegin(_etype966, _size963); + this->new_parts.resize(_size963); + uint32_t _i967; + for (_i967 = 0; _i967 < _size963; ++_i967) { - xfer += this->new_parts[_i956].read(iprot); + xfer += this->new_parts[_i967].read(iprot); } xfer += iprot->readListEnd(); } @@ -9200,10 +9471,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<PartitionSpec> ::const_iterator _iter957; - for (_iter957 = this->new_parts.begin(); _iter957 != this->new_parts.end(); ++_iter957) + std::vector<PartitionSpec> ::const_iterator _iter968; + for (_iter968 = this->new_parts.begin(); _iter968 != this->new_parts.end(); ++_iter968) { - xfer += (*_iter957).write(oprot); + xfer += (*_iter968).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9227,10 +9498,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<PartitionSpec> ::const_iterator _iter958; - for (_iter958 = (*(this->new_parts)).begin(); _iter958 != (*(this->new_parts)).end(); ++_iter958) + std::vector<PartitionSpec> ::const_iterator _iter969; + for (_iter969 = (*(this->new_parts)).begin(); _iter969 != (*(this->new_parts)).end(); ++_iter969) { - xfer += (*_iter958).write(oprot); + xfer += (*_iter969).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9455,14 +9726,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size959; - ::apache::thrift::protocol::TType _etype962; - xfer += iprot->readListBegin(_etype962, _size959); - this->part_vals.resize(_size959); - uint32_t _i963; - for (_i963 = 0; _i963 < _size959; ++_i963) + uint32_t _size970; + ::apache::thrift::protocol::TType _etype973; + xfer += iprot->readListBegin(_etype973, _size970); + this->part_vals.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += iprot->readString(this->part_vals[_i963]); + xfer += iprot->readString(this->part_vals[_i974]); } xfer += iprot->readListEnd(); } @@ -9499,10 +9770,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter964; - for (_iter964 = this->part_vals.begin(); _iter964 != this->part_vals.end(); ++_iter964) + std::vector<std::string> ::const_iterator _iter975; + for (_iter975 = this->part_vals.begin(); _iter975 != this->part_vals.end(); ++_iter975) { - xfer += oprot->writeString((*_iter964)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -9534,10 +9805,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter965; - for (_iter965 = (*(this->part_vals)).begin(); _iter965 != (*(this->part_vals)).end(); ++_iter965) + std::vector<std::string> ::const_iterator _iter976; + for (_iter976 = (*(this->part_vals)).begin(); _iter976 != (*(this->part_vals)).end(); ++_iter976) { - xfer += oprot->writeString((*_iter965)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -10009,14 +10280,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size966; - ::apache::thrift::protocol::TType _etype969; - xfer += iprot->readListBegin(_etype969, _size966); - this->part_vals.resize(_size966); - uint32_t _i970; - for (_i970 = 0; _i970 < _size966; ++_i970) + uint32_t _size977; + ::apache::thrift::protocol::TType _etype980; + xfer += iprot->readListBegin(_etype980, _size977); + this->part_vals.resize(_size977); + uint32_t _i981; + for (_i981 = 0; _i981 < _size977; ++_i981) { - xfer += iprot->readString(this->part_vals[_i970]); + xfer += iprot->readString(this->part_vals[_i981]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10332,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter971; - for (_iter971 = this->part_vals.begin(); _iter971 != this->part_vals.end(); ++_iter971) + std::vector<std::string> ::const_iterator _iter982; + for (_iter982 = this->part_vals.begin(); _iter982 != this->part_vals.end(); ++_iter982) { - xfer += oprot->writeString((*_iter971)); + xfer += oprot->writeString((*_iter982)); } xfer += oprot->writeListEnd(); } @@ -10100,10 +10371,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter972; - for (_iter972 = (*(this->part_vals)).begin(); _iter972 != (*(this->part_vals)).end(); ++_iter972) + std::vector<std::string> ::const_iterator _iter983; + for (_iter983 = (*(this->part_vals)).begin(); _iter983 != (*(this->part_vals)).end(); ++_iter983) { - xfer += oprot->writeString((*_iter972)); + xfer += oprot->writeString((*_iter983)); } xfer += oprot->writeListEnd(); } @@ -10906,14 +11177,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size973; - ::apache::thrift::protocol::TType _etype976; - xfer += iprot->readListBegin(_etype976, _size973); - this->part_vals.resize(_size973); - uint32_t _i977; - for (_i977 = 0; _i977 < _size973; ++_i977) + uint32_t _size984; + ::apache::thrift::protocol::TType _etype987; + xfer += iprot->readListBegin(_etype987, _size984); + this->part_vals.resize(_size984); + uint32_t _i988; + for (_i988 = 0; _i988 < _size984; ++_i988) { - xfer += iprot->readString(this->part_vals[_i977]); + xfer += iprot->readString(this->part_vals[_i988]); } xfer += iprot->readListEnd(); } @@ -10958,10 +11229,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter978; - for (_iter978 = this->part_vals.begin(); _iter978 != this->part_vals.end(); ++_iter978) + std::vector<std::string> ::const_iterator _iter989; + for (_iter989 = this->part_vals.begin(); _iter989 != this->part_vals.end(); ++_iter989) { - xfer += oprot->writeString((*_iter978)); + xfer += oprot->writeString((*_iter989)); } xfer += oprot->writeListEnd(); } @@ -10997,10 +11268,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter979; - for (_iter979 = (*(this->part_vals)).begin(); _iter979 != (*(this->part_vals)).end(); ++_iter979) + std::vector<std::string> ::const_iterator _iter990; + for (_iter990 = (*(this->part_vals)).begin(); _iter990 != (*(this->part_vals)).end(); ++_iter990) { - xfer += oprot->writeString((*_iter979)); + xfer += oprot->writeString((*_iter990)); } xfer += oprot->writeListEnd(); } @@ -11209,14 +11480,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size980; - ::apache::thrift::protocol::TType _etype983; - xfer += iprot->readListBegin(_etype983, _size980); - this->part_vals.resize(_size980); - uint32_t _i984; - for (_i984 = 0; _i984 < _size980; ++_i984) + uint32_t _size991; + ::apache::thrift::protocol::TType _etype994; + xfer += iprot->readListBegin(_etype994, _size991); + this->part_vals.resize(_size991); + uint32_t _i995; + for (_i995 = 0; _i995 < _size991; ++_i995) { - xfer += iprot->readString(this->part_vals[_i984]); + xfer += iprot->readString(this->part_vals[_i995]); } xfer += iprot->readListEnd(); } @@ -11269,10 +11540,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter985; - for (_iter985 = this->part_vals.begin(); _iter985 != this->part_vals.end(); ++_iter985) + std::vector<std::string> ::const_iterator _iter996; + for (_iter996 = this->part_vals.begin(); _iter996 != this->part_vals.end(); ++_iter996) { - xfer += oprot->writeString((*_iter985)); + xfer += oprot->writeString((*_iter996)); } xfer += oprot->writeListEnd(); } @@ -11312,10 +11583,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter986; - for (_iter986 = (*(this->part_vals)).begin(); _iter986 != (*(this->part_vals)).end(); ++_iter986) + std::vector<std::string> ::const_iterator _iter997; + for (_iter997 = (*(this->part_vals)).begin(); _iter997 != (*(this->part_vals)).end(); ++_iter997) { - xfer += oprot->writeString((*_iter986)); + xfer += oprot->writeString((*_iter997)); } xfer += oprot->writeListEnd(); } @@ -12321,14 +12592,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size987; - ::apache::thrift::protocol::TType _etype990; - xfer += iprot->readListBegin(_etype990, _size987); - this->part_vals.resize(_size987); - uint32_t _i991; - for (_i991 = 0; _i991 < _size987; ++_i991) + uint32_t _size998; + ::apache::thrift::protocol::TType _etype1001; + xfer += iprot->readListBegin(_etype1001, _size998); + this->part_vals.resize(_size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - xfer += iprot->readString(this->part_vals[_i991]); + xfer += iprot->readString(this->part_vals[_i1002]); } xfer += iprot->readListEnd(); } @@ -12365,10 +12636,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter992; - for (_iter992 = this->part_vals.begin(); _iter992 != this->part_vals.end(); ++_iter992) + std::vector<std::string> ::const_iterator _iter1003; + for (_iter1003 = this->part_vals.begin(); _iter1003 != this->part_vals.end(); ++_iter1003) { - xfer += oprot->writeString((*_iter992)); + xfer += oprot->writeString((*_iter1003)); } xfer += oprot->writeListEnd(); } @@ -12400,10 +12671,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter993; - for (_iter993 = (*(this->part_vals)).begin(); _iter993 != (*(this->part_vals)).end(); ++_iter993) + std::vector<std::string> ::const_iterator _iter1004; + for (_iter1004 = (*(this->part_vals)).begin(); _iter1004 != (*(this->part_vals)).end(); ++_iter1004) { - xfer += oprot->writeString((*_iter993)); + xfer += oprot->writeString((*_iter1004)); } xfer += oprot->writeListEnd(); } @@ -12592,17 +12863,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size994; - ::apache::thrift::protocol::TType _ktype995; - ::apache::thrift::protocol::TType _vtype996; - xfer += iprot->readMapBegin(_ktype995, _vtype996, _size994); - uint32_t _i998; - for (_i998 = 0; _i998 < _size994; ++_i998) + uint32_t _size1005; + ::apache::thrift::protocol::TType _ktype1006; + ::apache::thrift::protocol::TType _vtype1007; + xfer += iprot->readMapBegin(_ktype1006, _vtype1007, _size1005); + uint32_t _i1009; + for (_i1009 = 0; _i1009 < _size1005; ++_i1009) { - std::string _key999; - xfer += iprot->readString(_key999); - std::string& _val1000 = this->partitionSpecs[_key999]; - xfer += iprot->readString(_val1000); + std::string _key1010; + xfer += iprot->readString(_key1010); + std::string& _val1011 = this->partitionSpecs[_key1010]; + xfer += iprot->readString(_val1011); } xfer += iprot->readMapEnd(); } @@ -12663,11 +12934,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter1001; - for (_iter1001 = this->partitionSpecs.begin(); _iter1001 != this->partitionSpecs.end(); ++_iter1001) + std::map<std::string, std::string> ::const_iterator _iter1012; + for (_iter1012 = this->partitionSpecs.begin(); _iter1012 != this->partitionSpecs.end(); ++_iter1012) { - xfer += oprot->writeString(_iter1001->first); - xfer += oprot->writeString(_iter1001->second); + xfer += oprot->writeString(_iter1012->first); + xfer += oprot->writeString(_iter1012->second); } xfer += oprot->writeMapEnd(); } @@ -12707,11 +12978,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter1002; - for (_iter1002 = (*(this->partitionSpecs)).begin(); _iter1002 != (*(this->partitionSpecs)).end(); ++_iter1002) + std::map<std::string, std::string> ::const_iterator _iter1013; + for (_iter1013 = (*(this->partitionSpecs)).begin(); _iter1013 != (*(this->partitionSpecs)).end(); ++_iter1013) { - xfer += oprot->writeString(_iter1002->first); - xfer += oprot->writeString(_iter1002->second); + xfer += oprot->writeString(_iter1013->first); + xfer += oprot->writeString(_iter1013->second); } xfer += oprot->writeMapEnd(); } @@ -12956,17 +13227,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1003; - ::apache::thrift::protocol::TType _ktype1004; - ::apache::thrift::protocol::TType _vtype1005; - xfer += iprot->readMapBegin(_ktype1004, _vtype1005, _size1003); - uint32_t _i1007; - for (_i1007 = 0; _i1007 < _size1003; ++_i1007) + uint32_t _size1014; + ::apache::thrift::protocol::TType _ktype1015; + ::apache::thrift::protocol::TType _vtype1016; + xfer += iprot->readMapBegin(_ktype1015, _vtype1016, _size1014); + uint32_t _i1018; + for (_i1018 = 0; _i1018 < _size1014; ++_i1018) { - std::string _key1008; - xfer += iprot->readString(_key1008); - std::string& _val1009 = this->partitionSpecs[_key1008]; - xfer += iprot->readString(_val1009); + std::string _key1019; + xfer += iprot->readString(_key1019); + std::string& _val1020 = this->partitionSpecs[_key1019]; + xfer += iprot->readString(_val1020); } xfer += iprot->readMapEnd(); } @@ -13027,11 +13298,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter1010; - for (_iter1010 = this->partitionSpecs.begin(); _iter1010 != this->partitionSpecs.end(); ++_iter1010) + std::map<std::string, std::string> ::const_iterator _iter1021; + for (_iter1021 = this->partitionSpecs.begin(); _iter1021 != this->partitionSpecs.end(); ++_iter1021) { - xfer += oprot->writeString(_iter1010->first); - xfer += oprot->writeString(_iter1010->second); + xfer += oprot->writeString(_iter1021->first); + xfer += oprot->writeString(_iter1021->second); } xfer += oprot->writeMapEnd(); } @@ -13071,11 +13342,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter1011; - for (_iter1011 = (*(this->partitionSpecs)).begin(); _iter1011 != (*(this->partitionSpecs)).end(); ++_iter1011) + std::map<std::string, std::string> ::const_iterator _iter1022; + for (_iter1022 = (*(this->partitionSpecs)).begin(); _iter1022 != (*(this->partitionSpecs)).end(); ++_iter1022) { - xfer += oprot->writeString(_iter1011->first); - xfer += oprot->writeString(_iter1011->second); + xfer += oprot->writeString(_iter1022->first); + xfer += oprot->writeString(_iter1022->second); } xfer += oprot->writeMapEnd(); } @@ -13132,14 +13403,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1012; - ::apache::thrift::protocol::TType _etype1015; - xfer += iprot->readListBegin(_etype1015, _size1012); - this->success.resize(_size1012); - uint32_t _i1016; - for (_i1016 = 0; _i1016 < _size1012; ++_i1016) + uint32_t _size1023; + ::apache::thrift::protocol::TType _etype1026; + xfer += iprot->readListBegin(_etype1026, _size1023); + this->success.resize(_size1023); + uint32_t _i1027; + for (_i1027 = 0; _i1027 < _size1023; ++_i1027) { - xfer += this->success[_i1016].read(iprot); + xfer += this->success[_i1027].read(iprot); } xfer += iprot->readListEnd(); } @@ -13202,10 +13473,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1017; - for (_iter1017 = this->success.begin(); _iter1017 != this->success.end(); ++_iter1017) + std::vector<Partition> ::const_iterator _iter1028; + for (_iter1028 = this->success.begin(); _iter1028 != this->success.end(); ++_iter1028) { - xfer += (*_iter1017).write(oprot); + xfer += (*_iter1028).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13262,14 +13533,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - (*(this->success)).resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1029; + ::apache::thrift::protocol::TType _etype1032; + xfer += iprot->readListBegin(_etype1032, _size1029); + (*(this->success)).resize(_size1029); + uint32_t _i1033; + for (_i1033 = 0; _i1033 < _size1029; ++_i1033) { - xfer += (*(this->success))[_i1022].read(iprot); + xfer += (*(this->success))[_i1033].read(iprot); } xfer += iprot->readListEnd(); } @@ -13368,14 +13639,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1023; - ::apache::thrift::protocol::TType _etype1026; - xfer += iprot->readListBegin(_etype1026, _size1023); - this->part_vals.resize(_size1023); - uint32_t _i1027; - for (_i1027 = 0; _i1027 < _size1023; ++_i1027) + uint32_t _size1034; + ::apache::thrift::protocol::TType _etype1037; + xfer += iprot->readListBegin(_etype1037, _size1034); + this->part_vals.resize(_size1034); + uint32_t _i1038; + for (_i1038 = 0; _i1038 < _size1034; ++_i1038) { - xfer += iprot->readString(this->part_vals[_i1027]); + xfer += iprot->readString(this->part_vals[_i1038]); } xfer += iprot->readListEnd(); } @@ -13396,14 +13667,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1028; - ::apache::thrift::protocol::TType _etype1031; - xfer += iprot->readListBegin(_etype1031, _size1028); - this->group_names.resize(_size1028); - uint32_t _i1032; - for (_i1032 = 0; _i1032 < _size1028; ++_i1032) + uint32_t _size1039; + ::apache::thrift::protocol::TType _etype1042; + xfer += iprot->readListBegin(_etype1042, _size1039); + this->group_names.resize(_size1039); + uint32_t _i1043; + for (_i1043 = 0; _i1043 < _size1039; ++_i1043) { - xfer += iprot->readString(this->group_names[_i1032]); + xfer += iprot->readString(this->group_names[_i1043]); } xfer += iprot->readListEnd(); } @@ -13440,10 +13711,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1033; - for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) + std::vector<std::string> ::const_iterator _iter1044; + for (_iter1044 = this->part_vals.begin(); _iter1044 != this->part_vals.end(); ++_iter1044) { - xfer += oprot->writeString((*_iter1033)); + xfer += oprot->writeString((*_iter1044)); } xfer += oprot->writeListEnd(); } @@ -13456,10 +13727,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1034; - for (_iter1034 = this->group_names.begin(); _iter1034 != this->group_names.end(); ++_iter1034) + std::vector<std::string> ::const_iterator _iter1045; + for (_iter1045 = this->group_names.begin(); _iter1045 != this->group_names.end(); ++_iter1045) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1045)); } xfer += oprot->writeListEnd(); } @@ -13491,10 +13762,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1035; - for (_iter1035 = (*(this->part_vals)).begin(); _iter1035 != (*(this->part_vals)).end(); ++_iter1035) + std::vector<std::string> ::const_iterator _iter1046; + for (_iter1046 = (*(this->part_vals)).begin(); _iter1046 != (*(this->part_vals)).end(); ++_iter1046) { - xfer += oprot->writeString((*_iter1035)); + xfer += oprot->writeString((*_iter1046)); } xfer += oprot->writeListEnd(); } @@ -13507,10 +13778,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1036; - for (_iter1036 = (*(this->group_names)).begin(); _iter1036 != (*(this->group_names)).end(); ++_iter1036) + std::vector<std::string> ::const_iterator _iter1047; + for (_iter1047 = (*(this->group_names)).begin(); _iter1047 != (*(this->group_names)).end(); ++_iter1047) { - xfer += oprot->writeString((*_iter1036)); + xfer += oprot->writeString((*_iter1047)); } xfer += oprot->writeListEnd(); } @@ -14069,14 +14340,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1037; - ::apache::thrift::protocol::TType _etype1040; - xfer += iprot->readListBegin(_etype1040, _size1037); - this->success.resize(_size1037); - uint32_t _i1041; - for (_i1041 = 0; _i1041 < _size1037; ++_i1041) + uint32_t _size1048; + ::apache::thrift::protocol::TType _etype1051; + xfer += iprot->readListBegin(_etype1051, _size1048); + this->success.resize(_size1048); + uint32_t _i1052; + for (_i1052 = 0; _i1052 < _size1048; ++_i1052) { - xfer += this->success[_i1041].read(iprot); + xfer += this->success[_i1052].read(iprot); } xfer += iprot->readListEnd(); } @@ -14123,10 +14394,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1042; - for (_iter1042 = this->success.begin(); _iter1042 != this->success.end(); ++_iter1042) + std::vector<Partition> ::const_iterator _iter1053; + for (_iter1053 = this->success.begin(); _iter1053 != this->success.end(); ++_iter1053) { - xfer += (*_iter1042).write(oprot); + xfer += (*_iter1053).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14175,14 +14446,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1043; - ::apache::thrift::protocol::TType _etype1046; - xfer += iprot->readListBegin(_etype1046, _size1043); - (*(this->success)).resize(_size1043); - uint32_t _i1047; - for (_i1047 = 0; _i1047 < _size1043; ++_i1047) + uint32_t _size1054; + ::apache::thrift::protocol::TType _etype1057; + xfer += iprot->readListBegin(_etype1057, _size1054); + (*(this->success)).resize(_size1054); + uint32_t _i1058; + for (_i1058 = 0; _i1058 < _size1054; ++_i1058) { - xfer += (*(this->success))[_i1047].read(iprot); + xfer += (*(this->success))[_i1058].read(iprot); } xfer += iprot->readListEnd(); } @@ -14281,14 +14552,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1048; - ::apache::thrift::protocol::TType _etype1051; - xfer += iprot->readListBegin(_etype1051, _size1048); - this->group_names.resize(_size1048); - uint32_t _i1052; - for (_i1052 = 0; _i1052 < _size1048; ++_i1052) + uint32_t _size1059; + ::apache::thrift::protocol::TType _etype1062; + xfer += iprot->readListBegin(_etype1062, _size1059); + this->group_names.resize(_size1059); + uint32_t _i1063; + for (_i1063 = 0; _i1063 < _size1059; ++_i1063) { - xfer += iprot->readString(this->group_names[_i1052]); + xfer += iprot->readString(this->group_names[_i1063]); } xfer += iprot->readListEnd(); } @@ -14333,10 +14604,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1053; - for (_iter1053 = this->group_names.begin(); _iter1053 != this->group_names.end(); ++_iter1053) + std::vector<std::string> ::const_iterator _iter1064; + for (_iter1064 = this->group_names.begin(); _iter1064 != this->group_names.end(); ++_iter1064) { - xfer += oprot->writeString((*_iter1053)); + xfer += oprot->writeString((*_iter1064)); } xfer += oprot->writeListEnd(); } @@ -14376,10 +14647,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1054; - for (_iter1054 = (*(this->group_names)).begin(); _iter1054 != (*(this->group_names)).end(); ++_iter1054) + std::vector<std::string> ::const_iterator _iter1065; + for (_iter1065 = (*(this->group_names)).begin(); _iter1065 != (*(this->group_names)).end(); ++_iter1065) { - xfer += oprot->writeString((*_iter1054)); + xfer += oprot->writeString((*_iter1065)); } xfer += oprot->writeListEnd(); } @@ -14420,14 +14691,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1055; - ::apache::thrift::protocol::TType _etype1058; - xfer += iprot->readListBegin(_etype1058, _size1055); - this->success.resize(_size1055); - uint32_t _i1059; - for (_i1059 = 0; _i1059 < _size1055; ++_i1059) + uint32_t _size1066; + ::apache::thrift::protocol::TType _etype1069; + xfer += iprot->readListBegin(_etype1069, _size1066); + this->success.resize(_size1066); + uint32_t _i1070; + for (_i1070 = 0; _i1070 < _size1066; ++_i1070) { - xfer += this->success[_i1059].read(iprot); + xfer += this->success[_i1070].read(iprot); } xfer += iprot->readListEnd(); } @@ -14474,10 +14745,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1060; - for (_iter1060 = this->success.begin(); _iter1060 != this->success.end(); ++_iter1060) + std::vector<Partition> ::const_iterator _iter1071; + for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) { - xfer += (*_iter1060).write(oprot); + xfer += (*_iter1071).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14526,14 +14797,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1061; - ::apache::thrift::protocol::TType _etype1064; - xfer += iprot->readListBegin(_etype1064, _size1061); - (*(this->success)).resize(_size1061); - uint32_t _i1065; - for (_i1065 = 0; _i1065 < _size1061; ++_i1065) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + (*(this->success)).resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += (*(this->success))[_i1065].read(iprot); + xfer += (*(this->success))[_i1076].read(iprot); } xfer += iprot->readListEnd(); } @@ -14711,14 +14982,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - this->success.resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + uint32_t _size1077; + ::apache::thrift::protocol::TType _etype1080; + xfer += iprot->readListBegin(_etype1080, _size1077); + this->success.resize(_size1077); + uint32_t _i1081; + for (_i1081 = 0; _i1081 < _size1077; ++_i1081) { - xfer += this->success[_i1070].read(iprot); + xfer += this->success[_i1081].read(iprot); } xfer += iprot->readListEnd(); } @@ -14765,10 +15036,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<PartitionSpec> ::const_iterator _iter1071; - for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) + std::vector<PartitionSpec> ::const_iterator _iter1082; + for (_iter1082 = this->success.begin(); _iter1082 != this->success.end(); ++_iter1082) { - xfer += (*_iter1071).write(oprot); + xfer += (*_iter1082).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14817,14 +15088,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1072; - ::apache::thrift::protocol::TType _etype1075; - xfer += iprot->readListBegin(_etype1075, _size1072); - (*(this->success)).resize(_size1072); - uint32_t _i1076; - for (_i1076 = 0; _i1076 < _size1072; ++_i1076) + uint32_t _size1083; + ::apache::thrift::protocol::TType _etype1086; + xfer += iprot->readListBegin(_etype1086, _size1083); + (*(this->success)).resize(_size1083); + uint32_t _i1087; + for (_i1087 = 0; _i1087 < _size1083; ++_i1087) { - xfer += (*(this->success))[_i1076].read(iprot); + xfer += (*(this->success))[_i1087].read(iprot); } xfer += iprot->readListEnd(); } @@ -15002,14 +15273,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1077; - ::apache::thrift::protocol::TType _etype1080; - xfer += iprot->readListBegin(_etype1080, _size1077); - this->success.resize(_size1077); - uint32_t _i1081; - for (_i1081 = 0; _i1081 < _size1077; ++_i1081) + uint32_t _size1088; + ::apache::thrift::protocol::TType _etype1091; + xfer += iprot->readListBegin(_etype1091, _size1088); + this->success.resize(_size1088); + uint32_t _i1092; + for (_i1092 = 0; _i1092 < _size1088; ++_i1092) { - xfer += iprot->readString(this->success[_i1081]); + xfer += iprot->readString(this->success[_i1092]); } xfer += iprot->readListEnd(); } @@ -15048,10 +15319,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1082; - for (_iter1082 = this->success.begin(); _iter1082 != this->success.end(); ++_iter1082) + std::vector<std::string> ::const_iterator _iter1093; + for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) { - xfer += oprot->writeString((*_iter1082)); + xfer += oprot->writeString((*_iter1093)); } xfer += oprot->writeListEnd(); } @@ -15096,14 +15367,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1083; - ::apache::thrift::protocol::TType _etype1086; - xfer += iprot->readListBegin(_etype1086, _size1083); - (*(this->success)).resize(_size1083); - uint32_t _i1087; - for (_i1087 = 0; _i1087 < _size1083; ++_i1087) + uint32_t _size1094; + ::apache::thrift::protocol::TType _etype1097; + xfer += iprot->readListBegin(_etype1097, _size1094); + (*(this->success)).resize(_size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - xfer += iprot->readString((*(this->success))[_i1087]); + xfer += iprot->readString((*(this->success))[_i1098]); } xfer += iprot->readListEnd(); } @@ -15178,14 +15449,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - this->part_vals.resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->part_vals.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += iprot->readString(this->part_vals[_i1092]); + xfer += iprot->readString(this->part_vals[_i1103]); } xfer += iprot->readListEnd(); } @@ -15230,10 +15501,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1093; - for (_iter1093 = this->part_vals.begin(); _iter1093 != this->part_vals.end(); ++_iter1093) + std::vector<std::string> ::const_iterator _iter1104; + for (_iter1104 = this->part_vals.begin(); _iter1104 != this->part_vals.end(); ++_iter1104) { - xfer += oprot->writeString((*_iter1093)); + xfer += oprot->writeString((*_iter1104)); } xfer += oprot->writeListEnd(); } @@ -15269,10 +15540,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1094; - for (_iter1094 = (*(this->part_vals)).begin(); _iter1094 != (*(this->part_vals)).end(); ++_iter1094) + std::vector<std::string> ::const_iterator _iter1105; + for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) { - xfer += oprot->writeString((*_iter1094)); + xfer += oprot->writeString((*_iter1105)); } xfer += oprot->writeListEnd(); } @@ -15317,14 +15588,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1095; - ::apache::thrift::protocol::TType _etype1098; - xfer += iprot->readListBegin(_etype1098, _size1095); - this->success.resize(_size1095); - uint32_t _i1099; - for (_i1099 = 0; _i1099 < _size1095; ++_i1099) + uint32_t _size1106; + ::apache::thrift::protocol::TType _etype1109; + xfer += iprot->readListBegin(_etype1109, _size1106); + this->success.resize(_size1106); + uint32_t _i1110; + for (_i1110 = 0; _i1110 < _size1106; ++_i1110) { - xfer += this->success[_i1099].read(iprot); + xfer += this->success[_i1110].read(iprot); } xfer += iprot->readListEnd(); } @@ -15371,10 +15642,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1100; - for (_iter1100 = this->success.begin(); _iter1100 != this->success.end(); ++_iter1100) + std::vector<Partition> ::const_iterator _iter1111; + for (_iter1111 = this->success.begin(); _iter1111 != this->success.end(); ++_iter1111) { - xfer += (*_iter1100).write(oprot); + xfer += (*_iter1111).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15423,14 +15694,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1101; - ::apache::thrift::protocol::TType _etype1104; - xfer += iprot->readListBegin(_etype1104, _size1101); - (*(this->success)).resize(_size1101); - uint32_t _i1105; - for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + uint32_t _size1112; + ::apache::thrift::protocol::TType _etype1115; + xfer += iprot->readListBegin(_etype1115, _size1112); + (*(this->success)).resize(_size1112); + uint32_t _i1116; + for (_i1116 = 0; _i1116 < _size1112; ++_i1116) { - xfer += (*(this->success))[_i1105].read(iprot); + xfer += (*(this->success))[_i1116].read(iprot); } xfer += iprot->readListEnd(); } @@ -15513,14 +15784,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1106; - ::apache::thrift::protocol::TType _etype1109; - xfer += iprot->readListBegin(_etype1109, _size1106); - this->part_vals.resize(_size1106); - uint32_t _i1110; - for (_i1110 = 0; _i1110 < _size1106; ++_i1110) + uint32_t _size1117; + ::apache::thrift::protocol::TType _etype1120; + xfer += iprot->readListBegin(_etype1120, _size1117); + this->part_vals.resize(_size1117); + uint32_t _i1121; + for (_i1121 = 0; _i1121 < _size1117; ++_i1121) { - xfer += iprot->readString(this->part_vals[_i1110]); + xfer += iprot->readString(this->part_vals[_i1121]); } xfer += iprot->readListEnd(); } @@ -15549,14 +15820,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1111; - ::apache::thrift::protocol::TType _etype1114; - xfer += iprot->readListBegin(_etype1114, _size1111); - this->group_names.resize(_size1111); - uint32_t _i1115; - for (_i1115 = 0; _i1115 < _size1111; ++_i1115) + uint32_t _size1122; + ::apache::thrift::protocol::TType _etype1125; + xfer += iprot->readListBegin(_etype1125, _size1122); + this->group_names.resize(_size1122); + uint32_t _i1126; + for (_i1126 = 0; _i1126 < _size1122; ++_i1126) { - xfer += iprot->readString(this->group_names[_i1115]); + xfer += iprot->readString(this->group_names[_i1126]); } xfer += iprot->readListEnd(); } @@ -15593,10 +15864,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1116; - for (_iter1116 = this->part_vals.begin(); _iter1116 != this->part_vals.end(); ++_iter1116) + std::vector<std::string> ::const_iterator _iter1127; + for (_iter1127 = this->part_vals.begin(); _iter1127 != this->part_vals.end(); ++_iter1127) { - xfer += oprot->writeString((*_iter1116)); + xfer += oprot->writeString((*_iter1127)); } xfer += oprot->writeListEnd(); } @@ -15613,10 +15884,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1117; - for (_iter1117 = this->group_names.begin(); _iter1117 != this->group_names.end(); ++_iter1117) + std::vector<std::string> ::const_iterator _iter1128; + for (_iter1128 = this->group_names.begin(); _iter1128 != this->group_names.end(); ++_iter1128) { - xfer += oprot->writeString((*_iter1117)); + xfer += oprot->writeString((*_iter1128)); } xfer += oprot->writeListEnd(); } @@ -15648,10 +15919,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1118; - for (_iter1118 = (*(this->part_vals)).begin(); _iter1118 != (*(this->part_vals)).end(); ++_iter1118) + std::vector<std::string> ::const_iterator _iter1129; + for (_iter1129 = (*(this->part_vals)).begin(); _iter1129 != (*(this->part_vals)).end(); ++_iter1129) { - xfer += oprot->writeString((*_iter1118)); + xfer += oprot->writeString((*_iter1129)); } xfer += oprot->writeListEnd(); } @@ -15668,10 +15939,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1119; - for (_iter1119 = (*(this->group_names)).begin(); _iter1119 != (*(this->group_names)).end(); ++_iter1119) + std::vector<std::string> ::const_iterator _iter1130; + for (_iter1130 = (*(this->group_names)).begin(); _iter1130 != (*(this->group_names)).end(); ++_iter1130) { - xfer += oprot->writeString((*_iter1119)); + xfer += oprot->writeString((*_iter1130)); } xfer += oprot->writeListEnd(); } @@ -15712,14 +15983,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1120; - ::apache::thrift::protocol::TType _etype1123; - xfer += iprot->readListBegin(_etype1123, _size1120); - this->success.resize(_size1120); - uint32_t _i1124; - for (_i1124 = 0; _i1124 < _size1120; ++_i1124) + uint32_t _size1131; + ::apache::thrift::protocol::TType _etype1134; + xfer += iprot->readListBegin(_etype1134, _size1131); + this->success.resize(_size1131); + uint32_t _i1135; + for (_i1135 = 0; _i1135 < _size1131; ++_i1135) { - xfer += this->success[_i1124].read(iprot); + xfer += this->success[_i1135].read(iprot); } xfer += iprot->readListEnd(); } @@ -15766,10 +16037,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1125; - for (_iter1125 = this->success.begin(); _iter1125 != this->success.end(); ++_iter1125) + std::vector<Partition> ::const_iterator _iter1136; + for (_iter1136 = this->success.begin(); _iter1136 != this->success.end(); ++_iter1136) { - xfer += (*_iter1125).write(oprot); + xfer += (*_iter1136).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15818,14 +16089,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1126; - ::apache::thrift::protocol::TType _etype1129; - xfer += iprot->readListBegin(_etype1129, _size1126); - (*(this->success)).resize(_size1126); - uint32_t _i1130; - for (_i1130 = 0; _i1130 < _size1126; ++_i1130) + uint32_t _size1137; + ::apache::thrift::protocol::TType _etype1140; + xfer += iprot->readListBegin(_etype1140, _size1137); + (*(this->success)).resize(_size1137); + uint32_t _i1141; + for (_i1141 = 0; _i1141 < _size1137; ++_i1141) { - xfer += (*(this->success))[_i1130].read(iprot); + xfer += (*(this->success))[_i1141].read(iprot); } xfer += iprot->readListEnd(); } @@ -15908,14 +16179,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - this->part_vals.resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + uint32_t _size1142; + ::apache::thrift::protocol::TType _etype1145; + xfer += iprot->readListBegin(_etype1145, _size1142); + this->part_vals.resize(_size1142); + uint32_t _i1146; + for (_i1146 = 0; _i1146 < _size1142; ++_i1146) { - xfer += iprot->readString(this->part_vals[_i1135]); + xfer += iprot->readString(this->part_vals[_i1146]); } xfer += iprot->readListEnd(); } @@ -15960,10 +16231,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1136; - for (_iter1136 = this->part_vals.begin(); _iter1136 != this->part_vals.end(); ++_iter1136) + std::vector<std::string> ::const_iterator _iter1147; + for (_iter1147 = this->part_vals.begin(); _iter1147 != this->part_vals.end(); ++_iter1147) { - xfer += oprot->writeString((*_iter1136)); + xfer += oprot->writeString((*_iter1147)); } xfer += oprot->writeListEnd(); } @@ -15999,10 +16270,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1137; - for (_iter1137 = (*(this->part_vals)).begin(); _iter1137 != (*(this->part_vals)).end(); ++_iter1137) + std::vector<std::string> ::const_iterator _iter1148; + for (_iter1148 = (*(this->part_vals)).begin(); _iter1148 != (*(this->part_vals)).end(); ++_iter1148) { - xfer += oprot->writeString((*_iter1137)); + xfer += oprot->writeString((*_iter1148)); } xfer += oprot->writeListEnd(); } @@ -16047,14 +16318,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1138; - ::apache::thrift::protocol::TType _etype1141; - xfer += iprot->readListBegin(_etype1141, _size1138); - this->success.resize(_size1138); - uint32_t _i1142; - for (_i1142 = 0; _i1142 < _size1138; ++_i1142) + uint32_t _size1149; + ::apache::thrift::protocol::TType _etype1152; + xfer += iprot->readListBegin(_etype1152, _size1149); + this->success.resize(_size1149); + uint32_t _i1153; + for (_i1153 = 0; _i1153 < _size1149; ++_i1153) { - xfer += iprot->readString(this->success[_i1142]); + xfer += iprot->readString(this->success[_i1153]); } xfer += iprot->readListEnd(); } @@ -16101,10 +16372,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1143; - for (_iter1143 = this->success.begin(); _iter1143 != this->success.end(); ++_iter1143) + std::vector<std::string> ::const_iterator _ite
<TRUNCATED>
