http://git-wip-us.apache.org/repos/asf/hive/blob/c0b532fc/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 176b634..028c647 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 _size657; - ::apache::thrift::protocol::TType _etype660; - xfer += iprot->readListBegin(_etype660, _size657); - this->success.resize(_size657); - uint32_t _i661; - for (_i661 = 0; _i661 < _size657; ++_i661) + 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) { - xfer += iprot->readString(this->success[_i661]); + xfer += iprot->readString(this->success[_i663]); } 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 _iter662; - for (_iter662 = this->success.begin(); _iter662 != this->success.end(); ++_iter662) + std::vector<std::string> ::const_iterator _iter664; + for (_iter664 = this->success.begin(); _iter664 != this->success.end(); ++_iter664) { - xfer += oprot->writeString((*_iter662)); + xfer += oprot->writeString((*_iter664)); } 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 _size663; - ::apache::thrift::protocol::TType _etype666; - xfer += iprot->readListBegin(_etype666, _size663); - (*(this->success)).resize(_size663); - uint32_t _i667; - for (_i667 = 0; _i667 < _size663; ++_i667) + 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) { - xfer += iprot->readString((*(this->success))[_i667]); + xfer += iprot->readString((*(this->success))[_i669]); } 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 _size668; - ::apache::thrift::protocol::TType _etype671; - xfer += iprot->readListBegin(_etype671, _size668); - this->success.resize(_size668); - uint32_t _i672; - for (_i672 = 0; _i672 < _size668; ++_i672) + 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) { - xfer += iprot->readString(this->success[_i672]); + xfer += iprot->readString(this->success[_i674]); } 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 _iter673; - for (_iter673 = this->success.begin(); _iter673 != this->success.end(); ++_iter673) + std::vector<std::string> ::const_iterator _iter675; + for (_iter675 = this->success.begin(); _iter675 != this->success.end(); ++_iter675) { - xfer += oprot->writeString((*_iter673)); + xfer += oprot->writeString((*_iter675)); } 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 _size674; - ::apache::thrift::protocol::TType _etype677; - xfer += iprot->readListBegin(_etype677, _size674); - (*(this->success)).resize(_size674); - uint32_t _i678; - for (_i678 = 0; _i678 < _size674; ++_i678) + 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) { - xfer += iprot->readString((*(this->success))[_i678]); + xfer += iprot->readString((*(this->success))[_i680]); } 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 _size679; - ::apache::thrift::protocol::TType _ktype680; - ::apache::thrift::protocol::TType _vtype681; - xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); - uint32_t _i683; - for (_i683 = 0; _i683 < _size679; ++_i683) + 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) { - std::string _key684; - xfer += iprot->readString(_key684); - Type& _val685 = this->success[_key684]; - xfer += _val685.read(iprot); + std::string _key686; + xfer += iprot->readString(_key686); + Type& _val687 = this->success[_key686]; + xfer += _val687.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 _iter686; - for (_iter686 = this->success.begin(); _iter686 != this->success.end(); ++_iter686) + std::map<std::string, Type> ::const_iterator _iter688; + for (_iter688 = this->success.begin(); _iter688 != this->success.end(); ++_iter688) { - xfer += oprot->writeString(_iter686->first); - xfer += _iter686->second.write(oprot); + xfer += oprot->writeString(_iter688->first); + xfer += _iter688->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 _size687; - ::apache::thrift::protocol::TType _ktype688; - ::apache::thrift::protocol::TType _vtype689; - xfer += iprot->readMapBegin(_ktype688, _vtype689, _size687); - uint32_t _i691; - for (_i691 = 0; _i691 < _size687; ++_i691) + 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 _key692; - xfer += iprot->readString(_key692); - Type& _val693 = (*(this->success))[_key692]; - xfer += _val693.read(iprot); + std::string _key694; + xfer += iprot->readString(_key694); + Type& _val695 = (*(this->success))[_key694]; + xfer += _val695.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 _size694; - ::apache::thrift::protocol::TType _etype697; - xfer += iprot->readListBegin(_etype697, _size694); - this->success.resize(_size694); - uint32_t _i698; - for (_i698 = 0; _i698 < _size694; ++_i698) + 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) { - xfer += this->success[_i698].read(iprot); + xfer += this->success[_i700].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 _iter699; - for (_iter699 = this->success.begin(); _iter699 != this->success.end(); ++_iter699) + std::vector<FieldSchema> ::const_iterator _iter701; + for (_iter701 = this->success.begin(); _iter701 != this->success.end(); ++_iter701) { - xfer += (*_iter699).write(oprot); + xfer += (*_iter701).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 _size700; - ::apache::thrift::protocol::TType _etype703; - xfer += iprot->readListBegin(_etype703, _size700); - (*(this->success)).resize(_size700); - uint32_t _i704; - for (_i704 = 0; _i704 < _size700; ++_i704) + 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) { - xfer += (*(this->success))[_i704].read(iprot); + xfer += (*(this->success))[_i706].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 _size705; - ::apache::thrift::protocol::TType _etype708; - xfer += iprot->readListBegin(_etype708, _size705); - this->success.resize(_size705); - uint32_t _i709; - for (_i709 = 0; _i709 < _size705; ++_i709) + 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) { - xfer += this->success[_i709].read(iprot); + xfer += this->success[_i711].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 _iter710; - for (_iter710 = this->success.begin(); _iter710 != this->success.end(); ++_iter710) + std::vector<FieldSchema> ::const_iterator _iter712; + for (_iter712 = this->success.begin(); _iter712 != this->success.end(); ++_iter712) { - xfer += (*_iter710).write(oprot); + xfer += (*_iter712).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 _size711; - ::apache::thrift::protocol::TType _etype714; - xfer += iprot->readListBegin(_etype714, _size711); - (*(this->success)).resize(_size711); - uint32_t _i715; - for (_i715 = 0; _i715 < _size711; ++_i715) + 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) { - xfer += (*(this->success))[_i715].read(iprot); + xfer += (*(this->success))[_i717].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 _size716; - ::apache::thrift::protocol::TType _etype719; - xfer += iprot->readListBegin(_etype719, _size716); - this->success.resize(_size716); - uint32_t _i720; - for (_i720 = 0; _i720 < _size716; ++_i720) + 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) { - xfer += this->success[_i720].read(iprot); + xfer += this->success[_i722].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 _iter721; - for (_iter721 = this->success.begin(); _iter721 != this->success.end(); ++_iter721) + std::vector<FieldSchema> ::const_iterator _iter723; + for (_iter723 = this->success.begin(); _iter723 != this->success.end(); ++_iter723) { - xfer += (*_iter721).write(oprot); + xfer += (*_iter723).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 _size722; - ::apache::thrift::protocol::TType _etype725; - xfer += iprot->readListBegin(_etype725, _size722); - (*(this->success)).resize(_size722); - uint32_t _i726; - for (_i726 = 0; _i726 < _size722; ++_i726) + 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) { - xfer += (*(this->success))[_i726].read(iprot); + xfer += (*(this->success))[_i728].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 _size727; - ::apache::thrift::protocol::TType _etype730; - xfer += iprot->readListBegin(_etype730, _size727); - this->success.resize(_size727); - uint32_t _i731; - for (_i731 = 0; _i731 < _size727; ++_i731) + 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) { - xfer += this->success[_i731].read(iprot); + xfer += this->success[_i733].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 _iter732; - for (_iter732 = this->success.begin(); _iter732 != this->success.end(); ++_iter732) + std::vector<FieldSchema> ::const_iterator _iter734; + for (_iter734 = this->success.begin(); _iter734 != this->success.end(); ++_iter734) { - xfer += (*_iter732).write(oprot); + xfer += (*_iter734).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 _size733; - ::apache::thrift::protocol::TType _etype736; - xfer += iprot->readListBegin(_etype736, _size733); - (*(this->success)).resize(_size733); - uint32_t _i737; - for (_i737 = 0; _i737 < _size733; ++_i737) + 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) { - xfer += (*(this->success))[_i737].read(iprot); + xfer += (*(this->success))[_i739].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 _size738; - ::apache::thrift::protocol::TType _etype741; - xfer += iprot->readListBegin(_etype741, _size738); - this->success.resize(_size738); - uint32_t _i742; - for (_i742 = 0; _i742 < _size738; ++_i742) + 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) { - xfer += iprot->readString(this->success[_i742]); + xfer += iprot->readString(this->success[_i744]); } 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 _iter743; - for (_iter743 = this->success.begin(); _iter743 != this->success.end(); ++_iter743) + std::vector<std::string> ::const_iterator _iter745; + for (_iter745 = this->success.begin(); _iter745 != this->success.end(); ++_iter745) { - xfer += oprot->writeString((*_iter743)); + xfer += oprot->writeString((*_iter745)); } 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 _size744; - ::apache::thrift::protocol::TType _etype747; - xfer += iprot->readListBegin(_etype747, _size744); - (*(this->success)).resize(_size744); - uint32_t _i748; - for (_i748 = 0; _i748 < _size744; ++_i748) + 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) { - xfer += iprot->readString((*(this->success))[_i748]); + xfer += iprot->readString((*(this->success))[_i750]); } 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 _size749; - ::apache::thrift::protocol::TType _etype752; - xfer += iprot->readListBegin(_etype752, _size749); - this->success.resize(_size749); - uint32_t _i753; - for (_i753 = 0; _i753 < _size749; ++_i753) + 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) { - xfer += iprot->readString(this->success[_i753]); + xfer += iprot->readString(this->success[_i755]); } 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 _iter754; - for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) + std::vector<std::string> ::const_iterator _iter756; + for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) { - xfer += oprot->writeString((*_iter754)); + xfer += oprot->writeString((*_iter756)); } 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 _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - (*(this->success)).resize(_size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + 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) { - xfer += iprot->readString((*(this->success))[_i759]); + xfer += iprot->readString((*(this->success))[_i761]); } 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 _size760; - ::apache::thrift::protocol::TType _etype763; - xfer += iprot->readListBegin(_etype763, _size760); - this->tbl_names.resize(_size760); - uint32_t _i764; - for (_i764 = 0; _i764 < _size760; ++_i764) + 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) { - xfer += iprot->readString(this->tbl_names[_i764]); + xfer += iprot->readString(this->tbl_names[_i766]); } 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 _iter765; - for (_iter765 = this->tbl_names.begin(); _iter765 != this->tbl_names.end(); ++_iter765) + std::vector<std::string> ::const_iterator _iter767; + for (_iter767 = this->tbl_names.begin(); _iter767 != this->tbl_names.end(); ++_iter767) { - xfer += oprot->writeString((*_iter765)); + xfer += oprot->writeString((*_iter767)); } 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 _iter766; - for (_iter766 = (*(this->tbl_names)).begin(); _iter766 != (*(this->tbl_names)).end(); ++_iter766) + std::vector<std::string> ::const_iterator _iter768; + for (_iter768 = (*(this->tbl_names)).begin(); _iter768 != (*(this->tbl_names)).end(); ++_iter768) { - xfer += oprot->writeString((*_iter766)); + xfer += oprot->writeString((*_iter768)); } 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 _size767; - ::apache::thrift::protocol::TType _etype770; - xfer += iprot->readListBegin(_etype770, _size767); - this->success.resize(_size767); - uint32_t _i771; - for (_i771 = 0; _i771 < _size767; ++_i771) + 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) { - xfer += this->success[_i771].read(iprot); + xfer += this->success[_i773].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 _iter772; - for (_iter772 = this->success.begin(); _iter772 != this->success.end(); ++_iter772) + std::vector<Table> ::const_iterator _iter774; + for (_iter774 = this->success.begin(); _iter774 != this->success.end(); ++_iter774) { - xfer += (*_iter772).write(oprot); + xfer += (*_iter774).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 _size773; - ::apache::thrift::protocol::TType _etype776; - xfer += iprot->readListBegin(_etype776, _size773); - (*(this->success)).resize(_size773); - uint32_t _i777; - for (_i777 = 0; _i777 < _size773; ++_i777) + 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) { - xfer += (*(this->success))[_i777].read(iprot); + xfer += (*(this->success))[_i779].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 _size778; - ::apache::thrift::protocol::TType _etype781; - xfer += iprot->readListBegin(_etype781, _size778); - this->success.resize(_size778); - uint32_t _i782; - for (_i782 = 0; _i782 < _size778; ++_i782) + 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) { - xfer += iprot->readString(this->success[_i782]); + xfer += iprot->readString(this->success[_i784]); } 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 _iter783; - for (_iter783 = this->success.begin(); _iter783 != this->success.end(); ++_iter783) + std::vector<std::string> ::const_iterator _iter785; + for (_iter785 = this->success.begin(); _iter785 != this->success.end(); ++_iter785) { - xfer += oprot->writeString((*_iter783)); + xfer += oprot->writeString((*_iter785)); } 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 _size784; - ::apache::thrift::protocol::TType _etype787; - xfer += iprot->readListBegin(_etype787, _size784); - (*(this->success)).resize(_size784); - uint32_t _i788; - for (_i788 = 0; _i788 < _size784; ++_i788) + 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) { - xfer += iprot->readString((*(this->success))[_i788]); + xfer += iprot->readString((*(this->success))[_i790]); } 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 _size789; - ::apache::thrift::protocol::TType _etype792; - xfer += iprot->readListBegin(_etype792, _size789); - this->new_parts.resize(_size789); - uint32_t _i793; - for (_i793 = 0; _i793 < _size789; ++_i793) + 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) { - xfer += this->new_parts[_i793].read(iprot); + xfer += this->new_parts[_i795].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 _iter794; - for (_iter794 = this->new_parts.begin(); _iter794 != this->new_parts.end(); ++_iter794) + std::vector<Partition> ::const_iterator _iter796; + for (_iter796 = this->new_parts.begin(); _iter796 != this->new_parts.end(); ++_iter796) { - xfer += (*_iter794).write(oprot); + xfer += (*_iter796).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 _iter795; - for (_iter795 = (*(this->new_parts)).begin(); _iter795 != (*(this->new_parts)).end(); ++_iter795) + std::vector<Partition> ::const_iterator _iter797; + for (_iter797 = (*(this->new_parts)).begin(); _iter797 != (*(this->new_parts)).end(); ++_iter797) { - xfer += (*_iter795).write(oprot); + xfer += (*_iter797).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 _size796; - ::apache::thrift::protocol::TType _etype799; - xfer += iprot->readListBegin(_etype799, _size796); - this->new_parts.resize(_size796); - uint32_t _i800; - for (_i800 = 0; _i800 < _size796; ++_i800) + 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) { - xfer += this->new_parts[_i800].read(iprot); + xfer += this->new_parts[_i802].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 _iter801; - for (_iter801 = this->new_parts.begin(); _iter801 != this->new_parts.end(); ++_iter801) + std::vector<PartitionSpec> ::const_iterator _iter803; + for (_iter803 = this->new_parts.begin(); _iter803 != this->new_parts.end(); ++_iter803) { - xfer += (*_iter801).write(oprot); + xfer += (*_iter803).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 _iter802; - for (_iter802 = (*(this->new_parts)).begin(); _iter802 != (*(this->new_parts)).end(); ++_iter802) + std::vector<PartitionSpec> ::const_iterator _iter804; + for (_iter804 = (*(this->new_parts)).begin(); _iter804 != (*(this->new_parts)).end(); ++_iter804) { - xfer += (*_iter802).write(oprot); + xfer += (*_iter804).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 _size803; - ::apache::thrift::protocol::TType _etype806; - xfer += iprot->readListBegin(_etype806, _size803); - this->part_vals.resize(_size803); - uint32_t _i807; - for (_i807 = 0; _i807 < _size803; ++_i807) + 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) { - xfer += iprot->readString(this->part_vals[_i807]); + xfer += iprot->readString(this->part_vals[_i809]); } 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 _iter808; - for (_iter808 = this->part_vals.begin(); _iter808 != this->part_vals.end(); ++_iter808) + std::vector<std::string> ::const_iterator _iter810; + for (_iter810 = this->part_vals.begin(); _iter810 != this->part_vals.end(); ++_iter810) { - xfer += oprot->writeString((*_iter808)); + xfer += oprot->writeString((*_iter810)); } 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 _iter809; - for (_iter809 = (*(this->part_vals)).begin(); _iter809 != (*(this->part_vals)).end(); ++_iter809) + std::vector<std::string> ::const_iterator _iter811; + for (_iter811 = (*(this->part_vals)).begin(); _iter811 != (*(this->part_vals)).end(); ++_iter811) { - xfer += oprot->writeString((*_iter809)); + xfer += oprot->writeString((*_iter811)); } 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 _size810; - ::apache::thrift::protocol::TType _etype813; - xfer += iprot->readListBegin(_etype813, _size810); - this->part_vals.resize(_size810); - uint32_t _i814; - for (_i814 = 0; _i814 < _size810; ++_i814) + 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) { - xfer += iprot->readString(this->part_vals[_i814]); + xfer += iprot->readString(this->part_vals[_i816]); } 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 _iter815; - for (_iter815 = this->part_vals.begin(); _iter815 != this->part_vals.end(); ++_iter815) + std::vector<std::string> ::const_iterator _iter817; + for (_iter817 = this->part_vals.begin(); _iter817 != this->part_vals.end(); ++_iter817) { - xfer += oprot->writeString((*_iter815)); + xfer += oprot->writeString((*_iter817)); } 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 _iter816; - for (_iter816 = (*(this->part_vals)).begin(); _iter816 != (*(this->part_vals)).end(); ++_iter816) + std::vector<std::string> ::const_iterator _iter818; + for (_iter818 = (*(this->part_vals)).begin(); _iter818 != (*(this->part_vals)).end(); ++_iter818) { - xfer += oprot->writeString((*_iter816)); + xfer += oprot->writeString((*_iter818)); } 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 _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->part_vals.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + 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) { - xfer += iprot->readString(this->part_vals[_i821]); + xfer += iprot->readString(this->part_vals[_i823]); } 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 _iter822; - for (_iter822 = this->part_vals.begin(); _iter822 != this->part_vals.end(); ++_iter822) + std::vector<std::string> ::const_iterator _iter824; + for (_iter824 = this->part_vals.begin(); _iter824 != this->part_vals.end(); ++_iter824) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter824)); } 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 _iter823; - for (_iter823 = (*(this->part_vals)).begin(); _iter823 != (*(this->part_vals)).end(); ++_iter823) + std::vector<std::string> ::const_iterator _iter825; + for (_iter825 = (*(this->part_vals)).begin(); _iter825 != (*(this->part_vals)).end(); ++_iter825) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter825)); } 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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - this->part_vals.resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + 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) { - xfer += iprot->readString(this->part_vals[_i828]); + xfer += iprot->readString(this->part_vals[_i830]); } 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 _iter829; - for (_iter829 = this->part_vals.begin(); _iter829 != this->part_vals.end(); ++_iter829) + std::vector<std::string> ::const_iterator _iter831; + for (_iter831 = this->part_vals.begin(); _iter831 != this->part_vals.end(); ++_iter831) { - xfer += oprot->writeString((*_iter829)); + xfer += oprot->writeString((*_iter831)); } 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 _iter830; - for (_iter830 = (*(this->part_vals)).begin(); _iter830 != (*(this->part_vals)).end(); ++_iter830) + std::vector<std::string> ::const_iterator _iter832; + for (_iter832 = (*(this->part_vals)).begin(); _iter832 != (*(this->part_vals)).end(); ++_iter832) { - xfer += oprot->writeString((*_iter830)); + xfer += oprot->writeString((*_iter832)); } 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 _size831; - ::apache::thrift::protocol::TType _etype834; - xfer += iprot->readListBegin(_etype834, _size831); - this->part_vals.resize(_size831); - uint32_t _i835; - for (_i835 = 0; _i835 < _size831; ++_i835) + 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) { - xfer += iprot->readString(this->part_vals[_i835]); + xfer += iprot->readString(this->part_vals[_i837]); } 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 _iter836; - for (_iter836 = this->part_vals.begin(); _iter836 != this->part_vals.end(); ++_iter836) + std::vector<std::string> ::const_iterator _iter838; + for (_iter838 = this->part_vals.begin(); _iter838 != this->part_vals.end(); ++_iter838) { - xfer += oprot->writeString((*_iter836)); + xfer += oprot->writeString((*_iter838)); } 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 _iter837; - for (_iter837 = (*(this->part_vals)).begin(); _iter837 != (*(this->part_vals)).end(); ++_iter837) + std::vector<std::string> ::const_iterator _iter839; + for (_iter839 = (*(this->part_vals)).begin(); _iter839 != (*(this->part_vals)).end(); ++_iter839) { - xfer += oprot->writeString((*_iter837)); + xfer += oprot->writeString((*_iter839)); } 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 _size838; - ::apache::thrift::protocol::TType _ktype839; - ::apache::thrift::protocol::TType _vtype840; - xfer += iprot->readMapBegin(_ktype839, _vtype840, _size838); - uint32_t _i842; - for (_i842 = 0; _i842 < _size838; ++_i842) + 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) { - std::string _key843; - xfer += iprot->readString(_key843); - std::string& _val844 = this->partitionSpecs[_key843]; - xfer += iprot->readString(_val844); + std::string _key845; + xfer += iprot->readString(_key845); + std::string& _val846 = this->partitionSpecs[_key845]; + xfer += iprot->readString(_val846); } 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 _iter845; - for (_iter845 = this->partitionSpecs.begin(); _iter845 != this->partitionSpecs.end(); ++_iter845) + std::map<std::string, std::string> ::const_iterator _iter847; + for (_iter847 = this->partitionSpecs.begin(); _iter847 != this->partitionSpecs.end(); ++_iter847) { - xfer += oprot->writeString(_iter845->first); - xfer += oprot->writeString(_iter845->second); + xfer += oprot->writeString(_iter847->first); + xfer += oprot->writeString(_iter847->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 _iter846; - for (_iter846 = (*(this->partitionSpecs)).begin(); _iter846 != (*(this->partitionSpecs)).end(); ++_iter846) + std::map<std::string, std::string> ::const_iterator _iter848; + for (_iter848 = (*(this->partitionSpecs)).begin(); _iter848 != (*(this->partitionSpecs)).end(); ++_iter848) { - xfer += oprot->writeString(_iter846->first); - xfer += oprot->writeString(_iter846->second); + xfer += oprot->writeString(_iter848->first); + xfer += oprot->writeString(_iter848->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 _size847; - ::apache::thrift::protocol::TType _ktype848; - ::apache::thrift::protocol::TType _vtype849; - xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + 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) { - std::string _key852; - xfer += iprot->readString(_key852); - std::string& _val853 = this->partitionSpecs[_key852]; - xfer += iprot->readString(_val853); + std::string _key854; + xfer += iprot->readString(_key854); + std::string& _val855 = this->partitionSpecs[_key854]; + xfer += iprot->readString(_val855); } 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 _iter854; - for (_iter854 = this->partitionSpecs.begin(); _iter854 != this->partitionSpecs.end(); ++_iter854) + std::map<std::string, std::string> ::const_iterator _iter856; + for (_iter856 = this->partitionSpecs.begin(); _iter856 != this->partitionSpecs.end(); ++_iter856) { - xfer += oprot->writeString(_iter854->first); - xfer += oprot->writeString(_iter854->second); + xfer += oprot->writeString(_iter856->first); + xfer += oprot->writeString(_iter856->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 _iter855; - for (_iter855 = (*(this->partitionSpecs)).begin(); _iter855 != (*(this->partitionSpecs)).end(); ++_iter855) + std::map<std::string, std::string> ::const_iterator _iter857; + for (_iter857 = (*(this->partitionSpecs)).begin(); _iter857 != (*(this->partitionSpecs)).end(); ++_iter857) { - xfer += oprot->writeString(_iter855->first); - xfer += oprot->writeString(_iter855->second); + xfer += oprot->writeString(_iter857->first); + xfer += oprot->writeString(_iter857->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 _size856; - ::apache::thrift::protocol::TType _etype859; - xfer += iprot->readListBegin(_etype859, _size856); - this->success.resize(_size856); - uint32_t _i860; - for (_i860 = 0; _i860 < _size856; ++_i860) + 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) { - xfer += this->success[_i860].read(iprot); + xfer += this->success[_i862].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 _iter861; - for (_iter861 = this->success.begin(); _iter861 != this->success.end(); ++_iter861) + std::vector<Partition> ::const_iterator _iter863; + for (_iter863 = this->success.begin(); _iter863 != this->success.end(); ++_iter863) { - xfer += (*_iter861).write(oprot); + xfer += (*_iter863).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 _size862; - ::apache::thrift::protocol::TType _etype865; - xfer += iprot->readListBegin(_etype865, _size862); - (*(this->success)).resize(_size862); - uint32_t _i866; - for (_i866 = 0; _i866 < _size862; ++_i866) + 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) { - xfer += (*(this->success))[_i866].read(iprot); + xfer += (*(this->success))[_i868].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 _size867; - ::apache::thrift::protocol::TType _etype870; - xfer += iprot->readListBegin(_etype870, _size867); - this->part_vals.resize(_size867); - uint32_t _i871; - for (_i871 = 0; _i871 < _size867; ++_i871) + 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) { - xfer += iprot->readString(this->part_vals[_i871]); + xfer += iprot->readString(this->part_vals[_i873]); } 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 _size872; - ::apache::thrift::protocol::TType _etype875; - xfer += iprot->readListBegin(_etype875, _size872); - this->group_names.resize(_size872); - uint32_t _i876; - for (_i876 = 0; _i876 < _size872; ++_i876) + 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) { - xfer += iprot->readString(this->group_names[_i876]); + xfer += iprot->readString(this->group_names[_i878]); } 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 _iter877; - for (_iter877 = this->part_vals.begin(); _iter877 != this->part_vals.end(); ++_iter877) + std::vector<std::string> ::const_iterator _iter879; + for (_iter879 = this->part_vals.begin(); _iter879 != this->part_vals.end(); ++_iter879) { - xfer += oprot->writeString((*_iter877)); + xfer += oprot->writeString((*_iter879)); } 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 _iter878; - for (_iter878 = this->group_names.begin(); _iter878 != this->group_names.end(); ++_iter878) + std::vector<std::string> ::const_iterator _iter880; + for (_iter880 = this->group_names.begin(); _iter880 != this->group_names.end(); ++_iter880) { - xfer += oprot->writeString((*_iter878)); + xfer += oprot->writeString((*_iter880)); } 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 _iter879; - for (_iter879 = (*(this->part_vals)).begin(); _iter879 != (*(this->part_vals)).end(); ++_iter879) + std::vector<std::string> ::const_iterator _iter881; + for (_iter881 = (*(this->part_vals)).begin(); _iter881 != (*(this->part_vals)).end(); ++_iter881) { - xfer += oprot->writeString((*_iter879)); + xfer += oprot->writeString((*_iter881)); } 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 _iter880; - for (_iter880 = (*(this->group_names)).begin(); _iter880 != (*(this->group_names)).end(); ++_iter880) + std::vector<std::string> ::const_iterator _iter882; + for (_iter882 = (*(this->group_names)).begin(); _iter882 != (*(this->group_names)).end(); ++_iter882) { - xfer += oprot->writeString((*_iter880)); + xfer += oprot->writeString((*_iter882)); } 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 _size881; - ::apache::thrift::protocol::TType _etype884; - xfer += iprot->readListBegin(_etype884, _size881); - this->success.resize(_size881); - uint32_t _i885; - for (_i885 = 0; _i885 < _size881; ++_i885) + 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) { - xfer += this->success[_i885].read(iprot); + xfer += this->success[_i887].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 _iter886; - for (_iter886 = this->success.begin(); _iter886 != this->success.end(); ++_iter886) + std::vector<Partition> ::const_iterator _iter888; + for (_iter888 = this->success.begin(); _iter888 != this->success.end(); ++_iter888) { - xfer += (*_iter886).write(oprot); + xfer += (*_iter888).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 _size887; - ::apache::thrift::protocol::TType _etype890; - xfer += iprot->readListBegin(_etype890, _size887); - (*(this->success)).resize(_size887); - uint32_t _i891; - for (_i891 = 0; _i891 < _size887; ++_i891) + 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) { - xfer += (*(this->success))[_i891].read(iprot); + xfer += (*(this->success))[_i893].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 _size892; - ::apache::thrift::protocol::TType _etype895; - xfer += iprot->readListBegin(_etype895, _size892); - this->group_names.resize(_size892); - uint32_t _i896; - for (_i896 = 0; _i896 < _size892; ++_i896) + 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) { - xfer += iprot->readString(this->group_names[_i896]); + xfer += iprot->readString(this->group_names[_i898]); } 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 _iter897; - for (_iter897 = this->group_names.begin(); _iter897 != this->group_names.end(); ++_iter897) + std::vector<std::string> ::const_iterator _iter899; + for (_iter899 = this->group_names.begin(); _iter899 != this->group_names.end(); ++_iter899) { - xfer += oprot->writeString((*_iter897)); + xfer += oprot->writeString((*_iter899)); } 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 _iter898; - for (_iter898 = (*(this->group_names)).begin(); _iter898 != (*(this->group_names)).end(); ++_iter898) + std::vector<std::string> ::const_iterator _iter900; + for (_iter900 = (*(this->group_names)).begin(); _iter900 != (*(this->group_names)).end(); ++_iter900) { - xfer += oprot->writeString((*_iter898)); + xfer += oprot->writeString((*_iter900)); } 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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->success.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + 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) { - xfer += this->success[_i903].read(iprot); + xfer += this->success[_i905].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 _iter904; - for (_iter904 = this->success.begin(); _iter904 != this->success.end(); ++_iter904) + std::vector<Partition> ::const_iterator _iter906; + for (_iter906 = this->success.begin(); _iter906 != this->success.end(); ++_iter906) { - xfer += (*_iter904).write(oprot); + xfer += (*_iter906).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 _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 _size907; + ::apache::thrift::protocol::TType _etype910; + xfer += iprot->readListBegin(_etype910, _size907); + (*(this->success)).resize(_size907); + uint32_t _i911; + for (_i911 = 0; _i911 < _size907; ++_i911) { - xfer += (*(this->success))[_i909].read(iprot); + xfer += (*(this->success))[_i911].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 _size910; - ::apache::thrift::protocol::TType _etype913; - xfer += iprot->readListBegin(_etype913, _size910); - this->success.resize(_size910); - uint32_t _i914; - for (_i914 = 0; _i914 < _size910; ++_i914) + 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) { - xfer += this->success[_i914].read(iprot); + xfer += this->success[_i916].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 _iter915; - for (_iter915 = this->success.begin(); _iter915 != this->success.end(); ++_iter915) + std::vector<PartitionSpec> ::const_iterator _iter917; + for (_iter917 = this->success.begin(); _iter917 != this->success.end(); ++_iter917) { - xfer += (*_iter915).write(oprot); + xfer += (*_iter917).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 _size916; - ::apache::thrift::protocol::TType _etype919; - xfer += iprot->readListBegin(_etype919, _size916); - (*(this->success)).resize(_size916); - uint32_t _i920; - for (_i920 = 0; _i920 < _size916; ++_i920) + 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) { - xfer += (*(this->success))[_i920].read(iprot); + xfer += (*(this->success))[_i922].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 _size921; - ::apache::thrift::protocol::TType _etype924; - xfer += iprot->readListBegin(_etype924, _size921); - this->success.resize(_size921); - uint32_t _i925; - for (_i925 = 0; _i925 < _size921; ++_i925) + 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) { - xfer += iprot->readString(this->success[_i925]); + xfer += iprot->readString(this->success[_i927]); } 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 _iter926; - for (_iter926 = this->success.begin(); _iter926 != this->success.end(); ++_iter926) + std::vector<std::string> ::const_iterator _iter928; + for (_iter928 = this->success.begin(); _iter928 != this->success.end(); ++_iter928) { - xfer += oprot->writeString((*_iter926)); + xfer += oprot->writeString((*_iter928)); } 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 _size927; - ::apache::thrift::protocol::TType _etype930; - xfer += iprot->readListBegin(_etype930, _size927); - (*(this->success)).resize(_size927); - uint32_t _i931; - for (_i931 = 0; _i931 < _size927; ++_i931) + 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) { - xfer += iprot->readString((*(this->success))[_i931]); + xfer += iprot->readString((*(this->success))[_i933]); } 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 _size932; - ::apache::thrift::protocol::TType _etype935; - xfer += iprot->readListBegin(_etype935, _size932); - this->part_vals.resize(_size932); - uint32_t _i936; - for (_i936 = 0; _i936 < _size932; ++_i936) + 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) { - xfer += iprot->readString(this->part_vals[_i936]); + xfer += iprot->readString(this->part_vals[_i938]); } 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 _iter937; - for (_iter937 = this->part_vals.begin(); _iter937 != this->part_vals.end(); ++_iter937) + std::vector<std::string> ::const_iterator _iter939; + for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) { - xfer += oprot->writeString((*_iter937)); + xfer += oprot->writeString((*_iter939)); } 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 _iter938; - for (_iter938 = (*(this->part_vals)).begin(); _iter938 != (*(this->part_vals)).end(); ++_iter938) + std::vector<std::string> ::const_iterator _iter940; + for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) { - xfer += oprot->writeString((*_iter938)); + xfer += oprot->writeString((*_iter940)); } 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 _size939; - ::apache::thrift::protocol::TType _etype942; - xfer += iprot->readListBegin(_etype942, _size939); - this->success.resize(_size939); - uint32_t _i943; - for (_i943 = 0; _i943 < _size939; ++_i943) + 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) { - xfer += this->success[_i943].read(iprot); + xfer += this->success[_i945].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 _iter944; - for (_iter944 = this->success.begin(); _iter944 != this->success.end(); ++_iter944) + std::vector<Partition> ::const_iterator _iter946; + for (_iter946 = this->success.begin(); _iter946 != this->success.end(); ++_iter946) { - xfer += (*_iter944).write(oprot); + xfer += (*_iter946).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 _size945; - ::apache::thrift::protocol::TType _etype948; - xfer += iprot->readListBegin(_etype948, _size945); - (*(this->success)).resize(_size945); - uint32_t _i949; - for (_i949 = 0; _i949 < _size945; ++_i949) + 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) { - xfer += (*(this->success))[_i949].read(iprot); + xfer += (*(this->success))[_i951].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 _size950; - ::apache::thrift::protocol::TType _etype953; - xfer += iprot->readListBegin(_etype953, _size950); - this->part_vals.resize(_size950); - uint32_t _i954; - for (_i954 = 0; _i954 < _size950; ++_i954) + 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) { - xfer += iprot->readString(this->part_vals[_i954]); + xfer += iprot->readString(this->part_vals[_i956]); } 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 _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - this->group_names.resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + 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) { - xfer += iprot->readString(this->group_names[_i959]); + xfer += iprot->readString(this->group_names[_i961]); } 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 _iter960; - for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) + std::vector<std::string> ::const_iterator _iter962; + for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) { - xfer += oprot->writeString((*_iter960)); + xfer += oprot->writeString((*_iter962)); } 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 _iter961; - for (_iter961 = this->group_names.begin(); _iter961 != this->group_names.end(); ++_iter961) + std::vector<std::string> ::const_iterator _iter963; + for (_iter963 = this->group_names.begin(); _iter963 != this->group_names.end(); ++_iter963) { - xfer += oprot->writeString((*_iter961)); + xfer += oprot->writeString((*_iter963)); } xfer += oprot->writeListEnd(); } @@ -14393,10 +14393,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs
<TRUNCATED>
