http://git-wip-us.apache.org/repos/asf/hive/blob/6e0504d9/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 028c647..c2a208f 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size659; - ::apache::thrift::protocol::TType _etype662; - xfer += iprot->readListBegin(_etype662, _size659); - this->success.resize(_size659); - uint32_t _i663; - for (_i663 = 0; _i663 < _size659; ++_i663) + uint32_t _size667; + ::apache::thrift::protocol::TType _etype670; + xfer += iprot->readListBegin(_etype670, _size667); + this->success.resize(_size667); + uint32_t _i671; + for (_i671 = 0; _i671 < _size667; ++_i671) { - xfer += iprot->readString(this->success[_i663]); + xfer += iprot->readString(this->success[_i671]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto 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 _iter664; - for (_iter664 = this->success.begin(); _iter664 != this->success.end(); ++_iter664) + std::vector<std::string> ::const_iterator _iter672; + for (_iter672 = this->success.begin(); _iter672 != this->success.end(); ++_iter672) { - xfer += oprot->writeString((*_iter664)); + xfer += oprot->writeString((*_iter672)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size665; - ::apache::thrift::protocol::TType _etype668; - xfer += iprot->readListBegin(_etype668, _size665); - (*(this->success)).resize(_size665); - uint32_t _i669; - for (_i669 = 0; _i669 < _size665; ++_i669) + uint32_t _size673; + ::apache::thrift::protocol::TType _etype676; + xfer += iprot->readListBegin(_etype676, _size673); + (*(this->success)).resize(_size673); + uint32_t _i677; + for (_i677 = 0; _i677 < _size673; ++_i677) { - xfer += iprot->readString((*(this->success))[_i669]); + xfer += iprot->readString((*(this->success))[_i677]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size670; - ::apache::thrift::protocol::TType _etype673; - xfer += iprot->readListBegin(_etype673, _size670); - this->success.resize(_size670); - uint32_t _i674; - for (_i674 = 0; _i674 < _size670; ++_i674) + uint32_t _size678; + ::apache::thrift::protocol::TType _etype681; + xfer += iprot->readListBegin(_etype681, _size678); + this->success.resize(_size678); + uint32_t _i682; + for (_i682 = 0; _i682 < _size678; ++_i682) { - xfer += iprot->readString(this->success[_i674]); + xfer += iprot->readString(this->success[_i682]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p 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 _iter675; - for (_iter675 = this->success.begin(); _iter675 != this->success.end(); ++_iter675) + std::vector<std::string> ::const_iterator _iter683; + for (_iter683 = this->success.begin(); _iter683 != this->success.end(); ++_iter683) { - xfer += oprot->writeString((*_iter675)); + xfer += oprot->writeString((*_iter683)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size676; - ::apache::thrift::protocol::TType _etype679; - xfer += iprot->readListBegin(_etype679, _size676); - (*(this->success)).resize(_size676); - uint32_t _i680; - for (_i680 = 0; _i680 < _size676; ++_i680) + uint32_t _size684; + ::apache::thrift::protocol::TType _etype687; + xfer += iprot->readListBegin(_etype687, _size684); + (*(this->success)).resize(_size684); + uint32_t _i688; + for (_i688 = 0; _i688 < _size684; ++_i688) { - xfer += iprot->readString((*(this->success))[_i680]); + xfer += iprot->readString((*(this->success))[_i688]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size681; - ::apache::thrift::protocol::TType _ktype682; - ::apache::thrift::protocol::TType _vtype683; - xfer += iprot->readMapBegin(_ktype682, _vtype683, _size681); - uint32_t _i685; - for (_i685 = 0; _i685 < _size681; ++_i685) + uint32_t _size689; + ::apache::thrift::protocol::TType _ktype690; + ::apache::thrift::protocol::TType _vtype691; + xfer += iprot->readMapBegin(_ktype690, _vtype691, _size689); + uint32_t _i693; + for (_i693 = 0; _i693 < _size689; ++_i693) { - std::string _key686; - xfer += iprot->readString(_key686); - Type& _val687 = this->success[_key686]; - xfer += _val687.read(iprot); + std::string _key694; + xfer += iprot->readString(_key694); + Type& _val695 = this->success[_key694]; + xfer += _val695.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter688; - for (_iter688 = this->success.begin(); _iter688 != this->success.end(); ++_iter688) + std::map<std::string, Type> ::const_iterator _iter696; + for (_iter696 = this->success.begin(); _iter696 != this->success.end(); ++_iter696) { - xfer += oprot->writeString(_iter688->first); - xfer += _iter688->second.write(oprot); + xfer += oprot->writeString(_iter696->first); + xfer += _iter696->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size689; - ::apache::thrift::protocol::TType _ktype690; - ::apache::thrift::protocol::TType _vtype691; - xfer += iprot->readMapBegin(_ktype690, _vtype691, _size689); - uint32_t _i693; - for (_i693 = 0; _i693 < _size689; ++_i693) + uint32_t _size697; + ::apache::thrift::protocol::TType _ktype698; + ::apache::thrift::protocol::TType _vtype699; + xfer += iprot->readMapBegin(_ktype698, _vtype699, _size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - std::string _key694; - xfer += iprot->readString(_key694); - Type& _val695 = (*(this->success))[_key694]; - xfer += _val695.read(iprot); + std::string _key702; + xfer += iprot->readString(_key702); + Type& _val703 = (*(this->success))[_key702]; + xfer += _val703.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size696; - ::apache::thrift::protocol::TType _etype699; - xfer += iprot->readListBegin(_etype699, _size696); - this->success.resize(_size696); - uint32_t _i700; - for (_i700 = 0; _i700 < _size696; ++_i700) + uint32_t _size704; + ::apache::thrift::protocol::TType _etype707; + xfer += iprot->readListBegin(_etype707, _size704); + this->success.resize(_size704); + uint32_t _i708; + for (_i708 = 0; _i708 < _size704; ++_i708) { - xfer += this->success[_i700].read(iprot); + xfer += this->success[_i708].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol 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<FieldSchema> ::const_iterator _iter701; - for (_iter701 = this->success.begin(); _iter701 != this->success.end(); ++_iter701) + std::vector<FieldSchema> ::const_iterator _iter709; + for (_iter709 = this->success.begin(); _iter709 != this->success.end(); ++_iter709) { - xfer += (*_iter701).write(oprot); + xfer += (*_iter709).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size702; - ::apache::thrift::protocol::TType _etype705; - xfer += iprot->readListBegin(_etype705, _size702); - (*(this->success)).resize(_size702); - uint32_t _i706; - for (_i706 = 0; _i706 < _size702; ++_i706) + uint32_t _size710; + ::apache::thrift::protocol::TType _etype713; + xfer += iprot->readListBegin(_etype713, _size710); + (*(this->success)).resize(_size710); + uint32_t _i714; + for (_i714 = 0; _i714 < _size710; ++_i714) { - xfer += (*(this->success))[_i706].read(iprot); + xfer += (*(this->success))[_i714].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size707; - ::apache::thrift::protocol::TType _etype710; - xfer += iprot->readListBegin(_etype710, _size707); - this->success.resize(_size707); - uint32_t _i711; - for (_i711 = 0; _i711 < _size707; ++_i711) + uint32_t _size715; + ::apache::thrift::protocol::TType _etype718; + xfer += iprot->readListBegin(_etype718, _size715); + this->success.resize(_size715); + uint32_t _i719; + for (_i719 = 0; _i719 < _size715; ++_i719) { - xfer += this->success[_i711].read(iprot); + xfer += this->success[_i719].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: 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<FieldSchema> ::const_iterator _iter712; - for (_iter712 = this->success.begin(); _iter712 != this->success.end(); ++_iter712) + std::vector<FieldSchema> ::const_iterator _iter720; + for (_iter720 = this->success.begin(); _iter720 != this->success.end(); ++_iter720) { - xfer += (*_iter712).write(oprot); + xfer += (*_iter720).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size713; - ::apache::thrift::protocol::TType _etype716; - xfer += iprot->readListBegin(_etype716, _size713); - (*(this->success)).resize(_size713); - uint32_t _i717; - for (_i717 = 0; _i717 < _size713; ++_i717) + uint32_t _size721; + ::apache::thrift::protocol::TType _etype724; + xfer += iprot->readListBegin(_etype724, _size721); + (*(this->success)).resize(_size721); + uint32_t _i725; + for (_i725 = 0; _i725 < _size721; ++_i725) { - xfer += (*(this->success))[_i717].read(iprot); + xfer += (*(this->success))[_i725].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _etype721; - xfer += iprot->readListBegin(_etype721, _size718); - this->success.resize(_size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + uint32_t _size726; + ::apache::thrift::protocol::TType _etype729; + xfer += iprot->readListBegin(_etype729, _size726); + this->success.resize(_size726); + uint32_t _i730; + for (_i730 = 0; _i730 < _size726; ++_i730) { - xfer += this->success[_i722].read(iprot); + xfer += this->success[_i730].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol 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<FieldSchema> ::const_iterator _iter723; - for (_iter723 = this->success.begin(); _iter723 != this->success.end(); ++_iter723) + std::vector<FieldSchema> ::const_iterator _iter731; + for (_iter731 = this->success.begin(); _iter731 != this->success.end(); ++_iter731) { - xfer += (*_iter723).write(oprot); + xfer += (*_iter731).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size724; - ::apache::thrift::protocol::TType _etype727; - xfer += iprot->readListBegin(_etype727, _size724); - (*(this->success)).resize(_size724); - uint32_t _i728; - for (_i728 = 0; _i728 < _size724; ++_i728) + uint32_t _size732; + ::apache::thrift::protocol::TType _etype735; + xfer += iprot->readListBegin(_etype735, _size732); + (*(this->success)).resize(_size732); + uint32_t _i736; + for (_i736 = 0; _i736 < _size732; ++_i736) { - xfer += (*(this->success))[_i728].read(iprot); + xfer += (*(this->success))[_i736].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size729; - ::apache::thrift::protocol::TType _etype732; - xfer += iprot->readListBegin(_etype732, _size729); - this->success.resize(_size729); - uint32_t _i733; - for (_i733 = 0; _i733 < _size729; ++_i733) + uint32_t _size737; + ::apache::thrift::protocol::TType _etype740; + xfer += iprot->readListBegin(_etype740, _size737); + this->success.resize(_size737); + uint32_t _i741; + for (_i741 = 0; _i741 < _size737; ++_i741) { - xfer += this->success[_i733].read(iprot); + xfer += this->success[_i741].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: 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<FieldSchema> ::const_iterator _iter734; - for (_iter734 = this->success.begin(); _iter734 != this->success.end(); ++_iter734) + std::vector<FieldSchema> ::const_iterator _iter742; + for (_iter742 = this->success.begin(); _iter742 != this->success.end(); ++_iter742) { - xfer += (*_iter734).write(oprot); + xfer += (*_iter742).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size735; - ::apache::thrift::protocol::TType _etype738; - xfer += iprot->readListBegin(_etype738, _size735); - (*(this->success)).resize(_size735); - uint32_t _i739; - for (_i739 = 0; _i739 < _size735; ++_i739) + uint32_t _size743; + ::apache::thrift::protocol::TType _etype746; + xfer += iprot->readListBegin(_etype746, _size743); + (*(this->success)).resize(_size743); + uint32_t _i747; + for (_i747 = 0; _i747 < _size743; ++_i747) { - xfer += (*(this->success))[_i739].read(iprot); + xfer += (*(this->success))[_i747].read(iprot); } xfer += iprot->readListEnd(); } @@ -5099,14 +5099,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size740; - ::apache::thrift::protocol::TType _etype743; - xfer += iprot->readListBegin(_etype743, _size740); - this->success.resize(_size740); - uint32_t _i744; - for (_i744 = 0; _i744 < _size740; ++_i744) + uint32_t _size748; + ::apache::thrift::protocol::TType _etype751; + xfer += iprot->readListBegin(_etype751, _size748); + this->success.resize(_size748); + uint32_t _i752; + for (_i752 = 0; _i752 < _size748; ++_i752) { - xfer += iprot->readString(this->success[_i744]); + xfer += iprot->readString(this->success[_i752]); } xfer += iprot->readListEnd(); } @@ -5145,10 +5145,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol 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 _iter745; - for (_iter745 = this->success.begin(); _iter745 != this->success.end(); ++_iter745) + std::vector<std::string> ::const_iterator _iter753; + for (_iter753 = this->success.begin(); _iter753 != this->success.end(); ++_iter753) { - xfer += oprot->writeString((*_iter745)); + xfer += oprot->writeString((*_iter753)); } xfer += oprot->writeListEnd(); } @@ -5193,14 +5193,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size746; - ::apache::thrift::protocol::TType _etype749; - xfer += iprot->readListBegin(_etype749, _size746); - (*(this->success)).resize(_size746); - uint32_t _i750; - for (_i750 = 0; _i750 < _size746; ++_i750) + uint32_t _size754; + ::apache::thrift::protocol::TType _etype757; + xfer += iprot->readListBegin(_etype757, _size754); + (*(this->success)).resize(_size754); + uint32_t _i758; + for (_i758 = 0; _i758 < _size754; ++_i758) { - xfer += iprot->readString((*(this->success))[_i750]); + xfer += iprot->readString((*(this->success))[_i758]); } xfer += iprot->readListEnd(); } @@ -5338,14 +5338,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size751; - ::apache::thrift::protocol::TType _etype754; - xfer += iprot->readListBegin(_etype754, _size751); - this->success.resize(_size751); - uint32_t _i755; - for (_i755 = 0; _i755 < _size751; ++_i755) + uint32_t _size759; + ::apache::thrift::protocol::TType _etype762; + xfer += iprot->readListBegin(_etype762, _size759); + this->success.resize(_size759); + uint32_t _i763; + for (_i763 = 0; _i763 < _size759; ++_i763) { - xfer += iprot->readString(this->success[_i755]); + xfer += iprot->readString(this->success[_i763]); } xfer += iprot->readListEnd(); } @@ -5384,10 +5384,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 _iter756; - for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) + std::vector<std::string> ::const_iterator _iter764; + for (_iter764 = this->success.begin(); _iter764 != this->success.end(); ++_iter764) { - xfer += oprot->writeString((*_iter756)); + xfer += oprot->writeString((*_iter764)); } xfer += oprot->writeListEnd(); } @@ -5432,14 +5432,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size757; - ::apache::thrift::protocol::TType _etype760; - xfer += iprot->readListBegin(_etype760, _size757); - (*(this->success)).resize(_size757); - uint32_t _i761; - for (_i761 = 0; _i761 < _size757; ++_i761) + uint32_t _size765; + ::apache::thrift::protocol::TType _etype768; + xfer += iprot->readListBegin(_etype768, _size765); + (*(this->success)).resize(_size765); + uint32_t _i769; + for (_i769 = 0; _i769 < _size765; ++_i769) { - xfer += iprot->readString((*(this->success))[_i761]); + xfer += iprot->readString((*(this->success))[_i769]); } xfer += iprot->readListEnd(); } @@ -5749,14 +5749,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 _size762; - ::apache::thrift::protocol::TType _etype765; - xfer += iprot->readListBegin(_etype765, _size762); - this->tbl_names.resize(_size762); - uint32_t _i766; - for (_i766 = 0; _i766 < _size762; ++_i766) + uint32_t _size770; + ::apache::thrift::protocol::TType _etype773; + xfer += iprot->readListBegin(_etype773, _size770); + this->tbl_names.resize(_size770); + uint32_t _i774; + for (_i774 = 0; _i774 < _size770; ++_i774) { - xfer += iprot->readString(this->tbl_names[_i766]); + xfer += iprot->readString(this->tbl_names[_i774]); } xfer += iprot->readListEnd(); } @@ -5789,10 +5789,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 _iter767; - for (_iter767 = this->tbl_names.begin(); _iter767 != this->tbl_names.end(); ++_iter767) + std::vector<std::string> ::const_iterator _iter775; + for (_iter775 = this->tbl_names.begin(); _iter775 != this->tbl_names.end(); ++_iter775) { - xfer += oprot->writeString((*_iter767)); + xfer += oprot->writeString((*_iter775)); } xfer += oprot->writeListEnd(); } @@ -5820,10 +5820,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 _iter768; - for (_iter768 = (*(this->tbl_names)).begin(); _iter768 != (*(this->tbl_names)).end(); ++_iter768) + std::vector<std::string> ::const_iterator _iter776; + for (_iter776 = (*(this->tbl_names)).begin(); _iter776 != (*(this->tbl_names)).end(); ++_iter776) { - xfer += oprot->writeString((*_iter768)); + xfer += oprot->writeString((*_iter776)); } xfer += oprot->writeListEnd(); } @@ -5864,14 +5864,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 _size769; - ::apache::thrift::protocol::TType _etype772; - xfer += iprot->readListBegin(_etype772, _size769); - this->success.resize(_size769); - uint32_t _i773; - for (_i773 = 0; _i773 < _size769; ++_i773) + uint32_t _size777; + ::apache::thrift::protocol::TType _etype780; + xfer += iprot->readListBegin(_etype780, _size777); + this->success.resize(_size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - xfer += this->success[_i773].read(iprot); + xfer += this->success[_i781].read(iprot); } xfer += iprot->readListEnd(); } @@ -5926,10 +5926,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 _iter774; - for (_iter774 = this->success.begin(); _iter774 != this->success.end(); ++_iter774) + std::vector<Table> ::const_iterator _iter782; + for (_iter782 = this->success.begin(); _iter782 != this->success.end(); ++_iter782) { - xfer += (*_iter774).write(oprot); + xfer += (*_iter782).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +5982,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 _size775; - ::apache::thrift::protocol::TType _etype778; - xfer += iprot->readListBegin(_etype778, _size775); - (*(this->success)).resize(_size775); - uint32_t _i779; - for (_i779 = 0; _i779 < _size775; ++_i779) + uint32_t _size783; + ::apache::thrift::protocol::TType _etype786; + xfer += iprot->readListBegin(_etype786, _size783); + (*(this->success)).resize(_size783); + uint32_t _i787; + for (_i787 = 0; _i787 < _size783; ++_i787) { - xfer += (*(this->success))[_i779].read(iprot); + xfer += (*(this->success))[_i787].read(iprot); } xfer += iprot->readListEnd(); } @@ -6175,14 +6175,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 _size780; - ::apache::thrift::protocol::TType _etype783; - xfer += iprot->readListBegin(_etype783, _size780); - this->success.resize(_size780); - uint32_t _i784; - for (_i784 = 0; _i784 < _size780; ++_i784) + uint32_t _size788; + ::apache::thrift::protocol::TType _etype791; + xfer += iprot->readListBegin(_etype791, _size788); + this->success.resize(_size788); + uint32_t _i792; + for (_i792 = 0; _i792 < _size788; ++_i792) { - xfer += iprot->readString(this->success[_i784]); + xfer += iprot->readString(this->success[_i792]); } xfer += iprot->readListEnd(); } @@ -6237,10 +6237,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 _iter785; - for (_iter785 = this->success.begin(); _iter785 != this->success.end(); ++_iter785) + std::vector<std::string> ::const_iterator _iter793; + for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) { - xfer += oprot->writeString((*_iter785)); + xfer += oprot->writeString((*_iter793)); } xfer += oprot->writeListEnd(); } @@ -6293,14 +6293,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 _size786; - ::apache::thrift::protocol::TType _etype789; - xfer += iprot->readListBegin(_etype789, _size786); - (*(this->success)).resize(_size786); - uint32_t _i790; - for (_i790 = 0; _i790 < _size786; ++_i790) + uint32_t _size794; + ::apache::thrift::protocol::TType _etype797; + xfer += iprot->readListBegin(_etype797, _size794); + (*(this->success)).resize(_size794); + uint32_t _i798; + for (_i798 = 0; _i798 < _size794; ++_i798) { - xfer += iprot->readString((*(this->success))[_i790]); + xfer += iprot->readString((*(this->success))[_i798]); } xfer += iprot->readListEnd(); } @@ -7634,14 +7634,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size791; - ::apache::thrift::protocol::TType _etype794; - xfer += iprot->readListBegin(_etype794, _size791); - this->new_parts.resize(_size791); - uint32_t _i795; - for (_i795 = 0; _i795 < _size791; ++_i795) + uint32_t _size799; + ::apache::thrift::protocol::TType _etype802; + xfer += iprot->readListBegin(_etype802, _size799); + this->new_parts.resize(_size799); + uint32_t _i803; + for (_i803 = 0; _i803 < _size799; ++_i803) { - xfer += this->new_parts[_i795].read(iprot); + xfer += this->new_parts[_i803].read(iprot); } xfer += iprot->readListEnd(); } @@ -7670,10 +7670,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 _iter796; - for (_iter796 = this->new_parts.begin(); _iter796 != this->new_parts.end(); ++_iter796) + std::vector<Partition> ::const_iterator _iter804; + for (_iter804 = this->new_parts.begin(); _iter804 != this->new_parts.end(); ++_iter804) { - xfer += (*_iter796).write(oprot); + xfer += (*_iter804).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7697,10 +7697,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 _iter797; - for (_iter797 = (*(this->new_parts)).begin(); _iter797 != (*(this->new_parts)).end(); ++_iter797) + std::vector<Partition> ::const_iterator _iter805; + for (_iter805 = (*(this->new_parts)).begin(); _iter805 != (*(this->new_parts)).end(); ++_iter805) { - xfer += (*_iter797).write(oprot); + xfer += (*_iter805).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7909,14 +7909,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 _size798; - ::apache::thrift::protocol::TType _etype801; - xfer += iprot->readListBegin(_etype801, _size798); - this->new_parts.resize(_size798); - uint32_t _i802; - for (_i802 = 0; _i802 < _size798; ++_i802) + uint32_t _size806; + ::apache::thrift::protocol::TType _etype809; + xfer += iprot->readListBegin(_etype809, _size806); + this->new_parts.resize(_size806); + uint32_t _i810; + for (_i810 = 0; _i810 < _size806; ++_i810) { - xfer += this->new_parts[_i802].read(iprot); + xfer += this->new_parts[_i810].read(iprot); } xfer += iprot->readListEnd(); } @@ -7945,10 +7945,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 _iter803; - for (_iter803 = this->new_parts.begin(); _iter803 != this->new_parts.end(); ++_iter803) + std::vector<PartitionSpec> ::const_iterator _iter811; + for (_iter811 = this->new_parts.begin(); _iter811 != this->new_parts.end(); ++_iter811) { - xfer += (*_iter803).write(oprot); + xfer += (*_iter811).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7972,10 +7972,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 _iter804; - for (_iter804 = (*(this->new_parts)).begin(); _iter804 != (*(this->new_parts)).end(); ++_iter804) + std::vector<PartitionSpec> ::const_iterator _iter812; + for (_iter812 = (*(this->new_parts)).begin(); _iter812 != (*(this->new_parts)).end(); ++_iter812) { - xfer += (*_iter804).write(oprot); + xfer += (*_iter812).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8200,14 +8200,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size805; - ::apache::thrift::protocol::TType _etype808; - xfer += iprot->readListBegin(_etype808, _size805); - this->part_vals.resize(_size805); - uint32_t _i809; - for (_i809 = 0; _i809 < _size805; ++_i809) + uint32_t _size813; + ::apache::thrift::protocol::TType _etype816; + xfer += iprot->readListBegin(_etype816, _size813); + this->part_vals.resize(_size813); + uint32_t _i817; + for (_i817 = 0; _i817 < _size813; ++_i817) { - xfer += iprot->readString(this->part_vals[_i809]); + xfer += iprot->readString(this->part_vals[_i817]); } xfer += iprot->readListEnd(); } @@ -8244,10 +8244,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 _iter810; - for (_iter810 = this->part_vals.begin(); _iter810 != this->part_vals.end(); ++_iter810) + std::vector<std::string> ::const_iterator _iter818; + for (_iter818 = this->part_vals.begin(); _iter818 != this->part_vals.end(); ++_iter818) { - xfer += oprot->writeString((*_iter810)); + xfer += oprot->writeString((*_iter818)); } xfer += oprot->writeListEnd(); } @@ -8279,10 +8279,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 _iter811; - for (_iter811 = (*(this->part_vals)).begin(); _iter811 != (*(this->part_vals)).end(); ++_iter811) + std::vector<std::string> ::const_iterator _iter819; + for (_iter819 = (*(this->part_vals)).begin(); _iter819 != (*(this->part_vals)).end(); ++_iter819) { - xfer += oprot->writeString((*_iter811)); + xfer += oprot->writeString((*_iter819)); } xfer += oprot->writeListEnd(); } @@ -8754,14 +8754,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size812; - ::apache::thrift::protocol::TType _etype815; - xfer += iprot->readListBegin(_etype815, _size812); - this->part_vals.resize(_size812); - uint32_t _i816; - for (_i816 = 0; _i816 < _size812; ++_i816) + uint32_t _size820; + ::apache::thrift::protocol::TType _etype823; + xfer += iprot->readListBegin(_etype823, _size820); + this->part_vals.resize(_size820); + uint32_t _i824; + for (_i824 = 0; _i824 < _size820; ++_i824) { - xfer += iprot->readString(this->part_vals[_i816]); + xfer += iprot->readString(this->part_vals[_i824]); } xfer += iprot->readListEnd(); } @@ -8806,10 +8806,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 _iter817; - for (_iter817 = this->part_vals.begin(); _iter817 != this->part_vals.end(); ++_iter817) + std::vector<std::string> ::const_iterator _iter825; + for (_iter825 = this->part_vals.begin(); _iter825 != this->part_vals.end(); ++_iter825) { - xfer += oprot->writeString((*_iter817)); + xfer += oprot->writeString((*_iter825)); } xfer += oprot->writeListEnd(); } @@ -8845,10 +8845,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 _iter818; - for (_iter818 = (*(this->part_vals)).begin(); _iter818 != (*(this->part_vals)).end(); ++_iter818) + std::vector<std::string> ::const_iterator _iter826; + for (_iter826 = (*(this->part_vals)).begin(); _iter826 != (*(this->part_vals)).end(); ++_iter826) { - xfer += oprot->writeString((*_iter818)); + xfer += oprot->writeString((*_iter826)); } xfer += oprot->writeListEnd(); } @@ -9651,14 +9651,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size819; - ::apache::thrift::protocol::TType _etype822; - xfer += iprot->readListBegin(_etype822, _size819); - this->part_vals.resize(_size819); - uint32_t _i823; - for (_i823 = 0; _i823 < _size819; ++_i823) + uint32_t _size827; + ::apache::thrift::protocol::TType _etype830; + xfer += iprot->readListBegin(_etype830, _size827); + this->part_vals.resize(_size827); + uint32_t _i831; + for (_i831 = 0; _i831 < _size827; ++_i831) { - xfer += iprot->readString(this->part_vals[_i823]); + xfer += iprot->readString(this->part_vals[_i831]); } xfer += iprot->readListEnd(); } @@ -9703,10 +9703,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 _iter824; - for (_iter824 = this->part_vals.begin(); _iter824 != this->part_vals.end(); ++_iter824) + std::vector<std::string> ::const_iterator _iter832; + for (_iter832 = this->part_vals.begin(); _iter832 != this->part_vals.end(); ++_iter832) { - xfer += oprot->writeString((*_iter824)); + xfer += oprot->writeString((*_iter832)); } xfer += oprot->writeListEnd(); } @@ -9742,10 +9742,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 _iter825; - for (_iter825 = (*(this->part_vals)).begin(); _iter825 != (*(this->part_vals)).end(); ++_iter825) + std::vector<std::string> ::const_iterator _iter833; + for (_iter833 = (*(this->part_vals)).begin(); _iter833 != (*(this->part_vals)).end(); ++_iter833) { - xfer += oprot->writeString((*_iter825)); + xfer += oprot->writeString((*_iter833)); } xfer += oprot->writeListEnd(); } @@ -9954,14 +9954,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size826; - ::apache::thrift::protocol::TType _etype829; - xfer += iprot->readListBegin(_etype829, _size826); - this->part_vals.resize(_size826); - uint32_t _i830; - for (_i830 = 0; _i830 < _size826; ++_i830) + uint32_t _size834; + ::apache::thrift::protocol::TType _etype837; + xfer += iprot->readListBegin(_etype837, _size834); + this->part_vals.resize(_size834); + uint32_t _i838; + for (_i838 = 0; _i838 < _size834; ++_i838) { - xfer += iprot->readString(this->part_vals[_i830]); + xfer += iprot->readString(this->part_vals[_i838]); } xfer += iprot->readListEnd(); } @@ -10014,10 +10014,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 _iter831; - for (_iter831 = this->part_vals.begin(); _iter831 != this->part_vals.end(); ++_iter831) + std::vector<std::string> ::const_iterator _iter839; + for (_iter839 = this->part_vals.begin(); _iter839 != this->part_vals.end(); ++_iter839) { - xfer += oprot->writeString((*_iter831)); + xfer += oprot->writeString((*_iter839)); } xfer += oprot->writeListEnd(); } @@ -10057,10 +10057,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 _iter832; - for (_iter832 = (*(this->part_vals)).begin(); _iter832 != (*(this->part_vals)).end(); ++_iter832) + std::vector<std::string> ::const_iterator _iter840; + for (_iter840 = (*(this->part_vals)).begin(); _iter840 != (*(this->part_vals)).end(); ++_iter840) { - xfer += oprot->writeString((*_iter832)); + xfer += oprot->writeString((*_iter840)); } xfer += oprot->writeListEnd(); } @@ -11066,14 +11066,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size833; - ::apache::thrift::protocol::TType _etype836; - xfer += iprot->readListBegin(_etype836, _size833); - this->part_vals.resize(_size833); - uint32_t _i837; - for (_i837 = 0; _i837 < _size833; ++_i837) + uint32_t _size841; + ::apache::thrift::protocol::TType _etype844; + xfer += iprot->readListBegin(_etype844, _size841); + this->part_vals.resize(_size841); + uint32_t _i845; + for (_i845 = 0; _i845 < _size841; ++_i845) { - xfer += iprot->readString(this->part_vals[_i837]); + xfer += iprot->readString(this->part_vals[_i845]); } xfer += iprot->readListEnd(); } @@ -11110,10 +11110,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 _iter838; - for (_iter838 = this->part_vals.begin(); _iter838 != this->part_vals.end(); ++_iter838) + std::vector<std::string> ::const_iterator _iter846; + for (_iter846 = this->part_vals.begin(); _iter846 != this->part_vals.end(); ++_iter846) { - xfer += oprot->writeString((*_iter838)); + xfer += oprot->writeString((*_iter846)); } xfer += oprot->writeListEnd(); } @@ -11145,10 +11145,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 _iter839; - for (_iter839 = (*(this->part_vals)).begin(); _iter839 != (*(this->part_vals)).end(); ++_iter839) + std::vector<std::string> ::const_iterator _iter847; + for (_iter847 = (*(this->part_vals)).begin(); _iter847 != (*(this->part_vals)).end(); ++_iter847) { - xfer += oprot->writeString((*_iter839)); + xfer += oprot->writeString((*_iter847)); } xfer += oprot->writeListEnd(); } @@ -11337,17 +11337,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size840; - ::apache::thrift::protocol::TType _ktype841; - ::apache::thrift::protocol::TType _vtype842; - xfer += iprot->readMapBegin(_ktype841, _vtype842, _size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size848; + ::apache::thrift::protocol::TType _ktype849; + ::apache::thrift::protocol::TType _vtype850; + xfer += iprot->readMapBegin(_ktype849, _vtype850, _size848); + uint32_t _i852; + for (_i852 = 0; _i852 < _size848; ++_i852) { - std::string _key845; - xfer += iprot->readString(_key845); - std::string& _val846 = this->partitionSpecs[_key845]; - xfer += iprot->readString(_val846); + std::string _key853; + xfer += iprot->readString(_key853); + std::string& _val854 = this->partitionSpecs[_key853]; + xfer += iprot->readString(_val854); } xfer += iprot->readMapEnd(); } @@ -11408,11 +11408,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 _iter847; - for (_iter847 = this->partitionSpecs.begin(); _iter847 != this->partitionSpecs.end(); ++_iter847) + std::map<std::string, std::string> ::const_iterator _iter855; + for (_iter855 = this->partitionSpecs.begin(); _iter855 != this->partitionSpecs.end(); ++_iter855) { - xfer += oprot->writeString(_iter847->first); - xfer += oprot->writeString(_iter847->second); + xfer += oprot->writeString(_iter855->first); + xfer += oprot->writeString(_iter855->second); } xfer += oprot->writeMapEnd(); } @@ -11452,11 +11452,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 _iter848; - for (_iter848 = (*(this->partitionSpecs)).begin(); _iter848 != (*(this->partitionSpecs)).end(); ++_iter848) + std::map<std::string, std::string> ::const_iterator _iter856; + for (_iter856 = (*(this->partitionSpecs)).begin(); _iter856 != (*(this->partitionSpecs)).end(); ++_iter856) { - xfer += oprot->writeString(_iter848->first); - xfer += oprot->writeString(_iter848->second); + xfer += oprot->writeString(_iter856->first); + xfer += oprot->writeString(_iter856->second); } xfer += oprot->writeMapEnd(); } @@ -11701,17 +11701,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size849; - ::apache::thrift::protocol::TType _ktype850; - ::apache::thrift::protocol::TType _vtype851; - xfer += iprot->readMapBegin(_ktype850, _vtype851, _size849); - uint32_t _i853; - for (_i853 = 0; _i853 < _size849; ++_i853) + uint32_t _size857; + ::apache::thrift::protocol::TType _ktype858; + ::apache::thrift::protocol::TType _vtype859; + xfer += iprot->readMapBegin(_ktype858, _vtype859, _size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - std::string _key854; - xfer += iprot->readString(_key854); - std::string& _val855 = this->partitionSpecs[_key854]; - xfer += iprot->readString(_val855); + std::string _key862; + xfer += iprot->readString(_key862); + std::string& _val863 = this->partitionSpecs[_key862]; + xfer += iprot->readString(_val863); } xfer += iprot->readMapEnd(); } @@ -11772,11 +11772,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 _iter856; - for (_iter856 = this->partitionSpecs.begin(); _iter856 != this->partitionSpecs.end(); ++_iter856) + std::map<std::string, std::string> ::const_iterator _iter864; + for (_iter864 = this->partitionSpecs.begin(); _iter864 != this->partitionSpecs.end(); ++_iter864) { - xfer += oprot->writeString(_iter856->first); - xfer += oprot->writeString(_iter856->second); + xfer += oprot->writeString(_iter864->first); + xfer += oprot->writeString(_iter864->second); } xfer += oprot->writeMapEnd(); } @@ -11816,11 +11816,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 _iter857; - for (_iter857 = (*(this->partitionSpecs)).begin(); _iter857 != (*(this->partitionSpecs)).end(); ++_iter857) + std::map<std::string, std::string> ::const_iterator _iter865; + for (_iter865 = (*(this->partitionSpecs)).begin(); _iter865 != (*(this->partitionSpecs)).end(); ++_iter865) { - xfer += oprot->writeString(_iter857->first); - xfer += oprot->writeString(_iter857->second); + xfer += oprot->writeString(_iter865->first); + xfer += oprot->writeString(_iter865->second); } xfer += oprot->writeMapEnd(); } @@ -11877,14 +11877,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size858; - ::apache::thrift::protocol::TType _etype861; - xfer += iprot->readListBegin(_etype861, _size858); - this->success.resize(_size858); - uint32_t _i862; - for (_i862 = 0; _i862 < _size858; ++_i862) + uint32_t _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + this->success.resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += this->success[_i862].read(iprot); + xfer += this->success[_i870].read(iprot); } xfer += iprot->readListEnd(); } @@ -11947,10 +11947,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 _iter863; - for (_iter863 = this->success.begin(); _iter863 != this->success.end(); ++_iter863) + std::vector<Partition> ::const_iterator _iter871; + for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) { - xfer += (*_iter863).write(oprot); + xfer += (*_iter871).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12007,14 +12007,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size864; - ::apache::thrift::protocol::TType _etype867; - xfer += iprot->readListBegin(_etype867, _size864); - (*(this->success)).resize(_size864); - uint32_t _i868; - for (_i868 = 0; _i868 < _size864; ++_i868) + uint32_t _size872; + ::apache::thrift::protocol::TType _etype875; + xfer += iprot->readListBegin(_etype875, _size872); + (*(this->success)).resize(_size872); + uint32_t _i876; + for (_i876 = 0; _i876 < _size872; ++_i876) { - xfer += (*(this->success))[_i868].read(iprot); + xfer += (*(this->success))[_i876].read(iprot); } xfer += iprot->readListEnd(); } @@ -12113,14 +12113,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 _size869; - ::apache::thrift::protocol::TType _etype872; - xfer += iprot->readListBegin(_etype872, _size869); - this->part_vals.resize(_size869); - uint32_t _i873; - for (_i873 = 0; _i873 < _size869; ++_i873) + uint32_t _size877; + ::apache::thrift::protocol::TType _etype880; + xfer += iprot->readListBegin(_etype880, _size877); + this->part_vals.resize(_size877); + uint32_t _i881; + for (_i881 = 0; _i881 < _size877; ++_i881) { - xfer += iprot->readString(this->part_vals[_i873]); + xfer += iprot->readString(this->part_vals[_i881]); } xfer += iprot->readListEnd(); } @@ -12141,14 +12141,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 _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - this->group_names.resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + uint32_t _size882; + ::apache::thrift::protocol::TType _etype885; + xfer += iprot->readListBegin(_etype885, _size882); + this->group_names.resize(_size882); + uint32_t _i886; + for (_i886 = 0; _i886 < _size882; ++_i886) { - xfer += iprot->readString(this->group_names[_i878]); + xfer += iprot->readString(this->group_names[_i886]); } xfer += iprot->readListEnd(); } @@ -12185,10 +12185,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 _iter879; - for (_iter879 = this->part_vals.begin(); _iter879 != this->part_vals.end(); ++_iter879) + std::vector<std::string> ::const_iterator _iter887; + for (_iter887 = this->part_vals.begin(); _iter887 != this->part_vals.end(); ++_iter887) { - xfer += oprot->writeString((*_iter879)); + xfer += oprot->writeString((*_iter887)); } xfer += oprot->writeListEnd(); } @@ -12201,10 +12201,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 _iter880; - for (_iter880 = this->group_names.begin(); _iter880 != this->group_names.end(); ++_iter880) + std::vector<std::string> ::const_iterator _iter888; + for (_iter888 = this->group_names.begin(); _iter888 != this->group_names.end(); ++_iter888) { - xfer += oprot->writeString((*_iter880)); + xfer += oprot->writeString((*_iter888)); } xfer += oprot->writeListEnd(); } @@ -12236,10 +12236,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 _iter881; - for (_iter881 = (*(this->part_vals)).begin(); _iter881 != (*(this->part_vals)).end(); ++_iter881) + std::vector<std::string> ::const_iterator _iter889; + for (_iter889 = (*(this->part_vals)).begin(); _iter889 != (*(this->part_vals)).end(); ++_iter889) { - xfer += oprot->writeString((*_iter881)); + xfer += oprot->writeString((*_iter889)); } xfer += oprot->writeListEnd(); } @@ -12252,10 +12252,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 _iter882; - for (_iter882 = (*(this->group_names)).begin(); _iter882 != (*(this->group_names)).end(); ++_iter882) + std::vector<std::string> ::const_iterator _iter890; + for (_iter890 = (*(this->group_names)).begin(); _iter890 != (*(this->group_names)).end(); ++_iter890) { - xfer += oprot->writeString((*_iter882)); + xfer += oprot->writeString((*_iter890)); } xfer += oprot->writeListEnd(); } @@ -12814,14 +12814,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size883; - ::apache::thrift::protocol::TType _etype886; - xfer += iprot->readListBegin(_etype886, _size883); - this->success.resize(_size883); - uint32_t _i887; - for (_i887 = 0; _i887 < _size883; ++_i887) + uint32_t _size891; + ::apache::thrift::protocol::TType _etype894; + xfer += iprot->readListBegin(_etype894, _size891); + this->success.resize(_size891); + uint32_t _i895; + for (_i895 = 0; _i895 < _size891; ++_i895) { - xfer += this->success[_i887].read(iprot); + xfer += this->success[_i895].read(iprot); } xfer += iprot->readListEnd(); } @@ -12868,10 +12868,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 _iter888; - for (_iter888 = this->success.begin(); _iter888 != this->success.end(); ++_iter888) + std::vector<Partition> ::const_iterator _iter896; + for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) { - xfer += (*_iter888).write(oprot); + xfer += (*_iter896).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12920,14 +12920,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size889; - ::apache::thrift::protocol::TType _etype892; - xfer += iprot->readListBegin(_etype892, _size889); - (*(this->success)).resize(_size889); - uint32_t _i893; - for (_i893 = 0; _i893 < _size889; ++_i893) + uint32_t _size897; + ::apache::thrift::protocol::TType _etype900; + xfer += iprot->readListBegin(_etype900, _size897); + (*(this->success)).resize(_size897); + uint32_t _i901; + for (_i901 = 0; _i901 < _size897; ++_i901) { - xfer += (*(this->success))[_i893].read(iprot); + xfer += (*(this->success))[_i901].read(iprot); } xfer += iprot->readListEnd(); } @@ -13026,14 +13026,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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - this->group_names.resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size902; + ::apache::thrift::protocol::TType _etype905; + xfer += iprot->readListBegin(_etype905, _size902); + this->group_names.resize(_size902); + uint32_t _i906; + for (_i906 = 0; _i906 < _size902; ++_i906) { - xfer += iprot->readString(this->group_names[_i898]); + xfer += iprot->readString(this->group_names[_i906]); } xfer += iprot->readListEnd(); } @@ -13078,10 +13078,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 _iter899; - for (_iter899 = this->group_names.begin(); _iter899 != this->group_names.end(); ++_iter899) + std::vector<std::string> ::const_iterator _iter907; + for (_iter907 = this->group_names.begin(); _iter907 != this->group_names.end(); ++_iter907) { - xfer += oprot->writeString((*_iter899)); + xfer += oprot->writeString((*_iter907)); } xfer += oprot->writeListEnd(); } @@ -13121,10 +13121,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 _iter900; - for (_iter900 = (*(this->group_names)).begin(); _iter900 != (*(this->group_names)).end(); ++_iter900) + std::vector<std::string> ::const_iterator _iter908; + for (_iter908 = (*(this->group_names)).begin(); _iter908 != (*(this->group_names)).end(); ++_iter908) { - xfer += oprot->writeString((*_iter900)); + xfer += oprot->writeString((*_iter908)); } xfer += oprot->writeListEnd(); } @@ -13165,14 +13165,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size901; - ::apache::thrift::protocol::TType _etype904; - xfer += iprot->readListBegin(_etype904, _size901); - this->success.resize(_size901); - uint32_t _i905; - for (_i905 = 0; _i905 < _size901; ++_i905) + uint32_t _size909; + ::apache::thrift::protocol::TType _etype912; + xfer += iprot->readListBegin(_etype912, _size909); + this->success.resize(_size909); + uint32_t _i913; + for (_i913 = 0; _i913 < _size909; ++_i913) { - xfer += this->success[_i905].read(iprot); + xfer += this->success[_i913].read(iprot); } xfer += iprot->readListEnd(); } @@ -13219,10 +13219,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 _iter906; - for (_iter906 = this->success.begin(); _iter906 != this->success.end(); ++_iter906) + std::vector<Partition> ::const_iterator _iter914; + for (_iter914 = this->success.begin(); _iter914 != this->success.end(); ++_iter914) { - xfer += (*_iter906).write(oprot); + xfer += (*_iter914).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13271,14 +13271,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size907; - ::apache::thrift::protocol::TType _etype910; - xfer += iprot->readListBegin(_etype910, _size907); - (*(this->success)).resize(_size907); - uint32_t _i911; - for (_i911 = 0; _i911 < _size907; ++_i911) + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + (*(this->success)).resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += (*(this->success))[_i911].read(iprot); + xfer += (*(this->success))[_i919].read(iprot); } xfer += iprot->readListEnd(); } @@ -13456,14 +13456,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size912; - ::apache::thrift::protocol::TType _etype915; - xfer += iprot->readListBegin(_etype915, _size912); - this->success.resize(_size912); - uint32_t _i916; - for (_i916 = 0; _i916 < _size912; ++_i916) + uint32_t _size920; + ::apache::thrift::protocol::TType _etype923; + xfer += iprot->readListBegin(_etype923, _size920); + this->success.resize(_size920); + uint32_t _i924; + for (_i924 = 0; _i924 < _size920; ++_i924) { - xfer += this->success[_i916].read(iprot); + xfer += this->success[_i924].read(iprot); } xfer += iprot->readListEnd(); } @@ -13510,10 +13510,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 _iter917; - for (_iter917 = this->success.begin(); _iter917 != this->success.end(); ++_iter917) + std::vector<PartitionSpec> ::const_iterator _iter925; + for (_iter925 = this->success.begin(); _iter925 != this->success.end(); ++_iter925) { - xfer += (*_iter917).write(oprot); + xfer += (*_iter925).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13562,14 +13562,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size918; - ::apache::thrift::protocol::TType _etype921; - xfer += iprot->readListBegin(_etype921, _size918); - (*(this->success)).resize(_size918); - uint32_t _i922; - for (_i922 = 0; _i922 < _size918; ++_i922) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + (*(this->success)).resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += (*(this->success))[_i922].read(iprot); + xfer += (*(this->success))[_i930].read(iprot); } xfer += iprot->readListEnd(); } @@ -13747,14 +13747,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: 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 _size931; + ::apache::thrift::protocol::TType _etype934; + xfer += iprot->readListBegin(_etype934, _size931); + this->success.resize(_size931); + uint32_t _i935; + for (_i935 = 0; _i935 < _size931; ++_i935) { - xfer += iprot->readString(this->success[_i927]); + xfer += iprot->readString(this->success[_i935]); } xfer += iprot->readListEnd(); } @@ -13793,10 +13793,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 _iter928; - for (_iter928 = this->success.begin(); _iter928 != this->success.end(); ++_iter928) + std::vector<std::string> ::const_iterator _iter936; + for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) { - xfer += oprot->writeString((*_iter928)); + xfer += oprot->writeString((*_iter936)); } xfer += oprot->writeListEnd(); } @@ -13841,14 +13841,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: 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 _size937; + ::apache::thrift::protocol::TType _etype940; + xfer += iprot->readListBegin(_etype940, _size937); + (*(this->success)).resize(_size937); + uint32_t _i941; + for (_i941 = 0; _i941 < _size937; ++_i941) { - xfer += iprot->readString((*(this->success))[_i933]); + xfer += iprot->readString((*(this->success))[_i941]); } xfer += iprot->readListEnd(); } @@ -13923,14 +13923,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 _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->part_vals.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size942; + ::apache::thrift::protocol::TType _etype945; + xfer += iprot->readListBegin(_etype945, _size942); + this->part_vals.resize(_size942); + uint32_t _i946; + for (_i946 = 0; _i946 < _size942; ++_i946) { - xfer += iprot->readString(this->part_vals[_i938]); + xfer += iprot->readString(this->part_vals[_i946]); } xfer += iprot->readListEnd(); } @@ -13975,10 +13975,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 _iter939; - for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) + std::vector<std::string> ::const_iterator _iter947; + for (_iter947 = this->part_vals.begin(); _iter947 != this->part_vals.end(); ++_iter947) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter947)); } xfer += oprot->writeListEnd(); } @@ -14014,10 +14014,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 _iter940; - for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) + std::vector<std::string> ::const_iterator _iter948; + for (_iter948 = (*(this->part_vals)).begin(); _iter948 != (*(this->part_vals)).end(); ++_iter948) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter948)); } xfer += oprot->writeListEnd(); } @@ -14062,14 +14062,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->success.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size949; + ::apache::thrift::protocol::TType _etype952; + xfer += iprot->readListBegin(_etype952, _size949); + this->success.resize(_size949); + uint32_t _i953; + for (_i953 = 0; _i953 < _size949; ++_i953) { - xfer += this->success[_i945].read(iprot); + xfer += this->success[_i953].read(iprot); } xfer += iprot->readListEnd(); } @@ -14116,10 +14116,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 _iter946; - for (_iter946 = this->success.begin(); _iter946 != this->success.end(); ++_iter946) + std::vector<Partition> ::const_iterator _iter954; + for (_iter954 = this->success.begin(); _iter954 != this->success.end(); ++_iter954) { - xfer += (*_iter946).write(oprot); + xfer += (*_iter954).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14168,14 +14168,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size947; - ::apache::thrift::protocol::TType _etype950; - xfer += iprot->readListBegin(_etype950, _size947); - (*(this->success)).resize(_size947); - uint32_t _i951; - for (_i951 = 0; _i951 < _size947; ++_i951) + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + (*(this->success)).resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) { - xfer += (*(this->success))[_i951].read(iprot); + xfer += (*(this->success))[_i959].read(iprot); } xfer += iprot->readListEnd(); } @@ -14258,14 +14258,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 _size952; - ::apache::thrift::protocol::TType _etype955; - xfer += iprot->readListBegin(_etype955, _size952); - this->part_vals.resize(_size952); - uint32_t _i956; - for (_i956 = 0; _i956 < _size952; ++_i956) + uint32_t _size960; + ::apache::thrift::protocol::TType _etype963; + xfer += iprot->readListBegin(_etype963, _size960); + this->part_vals.resize(_size960); + uint32_t _i964; + for (_i964 = 0; _i964 < _size960; ++_i964) { - xfer += iprot->readString(this->part_vals[_i956]); + xfer += iprot->readString(this->part_vals[_i964]); } xfer += iprot->readListEnd(); } @@ -14294,14 +14294,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 _size957; - ::apache::thrift::protocol::TType _etype960; - xfer += iprot->readListBegin(_etype960, _size957); - this->group_names.resize(_size957); - uint32_t _i961; - for (_i961 = 0; _i961 < _size957; ++_i961) + uint32_t _size965; + ::apache::thrift::protocol::TType _etype968; + xfer += iprot->readListBegin(_etype968, _size965); + this->group_names.resize(_size965); + uint32_t _i969; + for (_i969 = 0; _i969 < _size965; ++_i969) { - xfer += iprot->readString(this->group_names[_i961]); + xfer += iprot->readString(this->group_names[_i969]); } xfer += iprot->readListEnd(); } @@ -14338,10 +14338,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 _iter962; - for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) + std::vector<std::string> ::const_iterator _iter970; + for (_iter970 = this->part_vals.begin(); _iter970 != this->part_vals.end(); ++_iter970) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter970)); } xfer += oprot->writeListEnd(); } @@ -14358,10 +14358,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 _iter963; - for (_iter963 = this->group_names.begin(); _iter963 != this->group_names.end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter971; + for (_iter971 = this->group_names.begin(); _iter971 != this->group_names.end(); ++_iter971) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -14393,10 +14393,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs
<TRUNCATED>