http://git-wip-us.apache.org/repos/asf/hive/blob/3e0d87f8/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 a82c363..44aa22e 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 _size714; - ::apache::thrift::protocol::TType _etype717; - xfer += iprot->readListBegin(_etype717, _size714); - this->success.resize(_size714); - uint32_t _i718; - for (_i718 = 0; _i718 < _size714; ++_i718) + 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 += iprot->readString(this->success[_i718]); + xfer += iprot->readString(this->success[_i717]); } 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 _iter719; - for (_iter719 = this->success.begin(); _iter719 != this->success.end(); ++_iter719) + std::vector<std::string> ::const_iterator _iter718; + for (_iter718 = this->success.begin(); _iter718 != this->success.end(); ++_iter718) { - xfer += oprot->writeString((*_iter719)); + xfer += oprot->writeString((*_iter718)); } 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 _size720; - ::apache::thrift::protocol::TType _etype723; - xfer += iprot->readListBegin(_etype723, _size720); - (*(this->success)).resize(_size720); - uint32_t _i724; - for (_i724 = 0; _i724 < _size720; ++_i724) + uint32_t _size719; + ::apache::thrift::protocol::TType _etype722; + xfer += iprot->readListBegin(_etype722, _size719); + (*(this->success)).resize(_size719); + uint32_t _i723; + for (_i723 = 0; _i723 < _size719; ++_i723) { - xfer += iprot->readString((*(this->success))[_i724]); + xfer += iprot->readString((*(this->success))[_i723]); } 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 _size725; - ::apache::thrift::protocol::TType _etype728; - xfer += iprot->readListBegin(_etype728, _size725); - this->success.resize(_size725); - uint32_t _i729; - for (_i729 = 0; _i729 < _size725; ++_i729) + 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 += iprot->readString(this->success[_i729]); + xfer += iprot->readString(this->success[_i728]); } 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 _iter730; - for (_iter730 = this->success.begin(); _iter730 != this->success.end(); ++_iter730) + std::vector<std::string> ::const_iterator _iter729; + for (_iter729 = this->success.begin(); _iter729 != this->success.end(); ++_iter729) { - xfer += oprot->writeString((*_iter730)); + xfer += oprot->writeString((*_iter729)); } 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 _size731; - ::apache::thrift::protocol::TType _etype734; - xfer += iprot->readListBegin(_etype734, _size731); - (*(this->success)).resize(_size731); - uint32_t _i735; - for (_i735 = 0; _i735 < _size731; ++_i735) + uint32_t _size730; + ::apache::thrift::protocol::TType _etype733; + xfer += iprot->readListBegin(_etype733, _size730); + (*(this->success)).resize(_size730); + uint32_t _i734; + for (_i734 = 0; _i734 < _size730; ++_i734) { - xfer += iprot->readString((*(this->success))[_i735]); + xfer += iprot->readString((*(this->success))[_i734]); } 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 _size736; - ::apache::thrift::protocol::TType _ktype737; - ::apache::thrift::protocol::TType _vtype738; - xfer += iprot->readMapBegin(_ktype737, _vtype738, _size736); - uint32_t _i740; - for (_i740 = 0; _i740 < _size736; ++_i740) + uint32_t _size735; + ::apache::thrift::protocol::TType _ktype736; + ::apache::thrift::protocol::TType _vtype737; + xfer += iprot->readMapBegin(_ktype736, _vtype737, _size735); + uint32_t _i739; + for (_i739 = 0; _i739 < _size735; ++_i739) { - std::string _key741; - xfer += iprot->readString(_key741); - Type& _val742 = this->success[_key741]; - xfer += _val742.read(iprot); + std::string _key740; + xfer += iprot->readString(_key740); + Type& _val741 = this->success[_key740]; + xfer += _val741.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 _iter743; - for (_iter743 = this->success.begin(); _iter743 != this->success.end(); ++_iter743) + std::map<std::string, Type> ::const_iterator _iter742; + for (_iter742 = this->success.begin(); _iter742 != this->success.end(); ++_iter742) { - xfer += oprot->writeString(_iter743->first); - xfer += _iter743->second.write(oprot); + xfer += oprot->writeString(_iter742->first); + xfer += _iter742->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 _size744; - ::apache::thrift::protocol::TType _ktype745; - ::apache::thrift::protocol::TType _vtype746; - xfer += iprot->readMapBegin(_ktype745, _vtype746, _size744); - uint32_t _i748; - for (_i748 = 0; _i748 < _size744; ++_i748) + uint32_t _size743; + ::apache::thrift::protocol::TType _ktype744; + ::apache::thrift::protocol::TType _vtype745; + xfer += iprot->readMapBegin(_ktype744, _vtype745, _size743); + uint32_t _i747; + for (_i747 = 0; _i747 < _size743; ++_i747) { - std::string _key749; - xfer += iprot->readString(_key749); - Type& _val750 = (*(this->success))[_key749]; - xfer += _val750.read(iprot); + std::string _key748; + xfer += iprot->readString(_key748); + Type& _val749 = (*(this->success))[_key748]; + xfer += _val749.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 _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 _size750; + ::apache::thrift::protocol::TType _etype753; + xfer += iprot->readListBegin(_etype753, _size750); + this->success.resize(_size750); + uint32_t _i754; + for (_i754 = 0; _i754 < _size750; ++_i754) { - xfer += this->success[_i755].read(iprot); + xfer += this->success[_i754].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 _iter756; - for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) + std::vector<FieldSchema> ::const_iterator _iter755; + for (_iter755 = this->success.begin(); _iter755 != this->success.end(); ++_iter755) { - xfer += (*_iter756).write(oprot); + xfer += (*_iter755).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 _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 _size756; + ::apache::thrift::protocol::TType _etype759; + xfer += iprot->readListBegin(_etype759, _size756); + (*(this->success)).resize(_size756); + uint32_t _i760; + for (_i760 = 0; _i760 < _size756; ++_i760) { - xfer += (*(this->success))[_i761].read(iprot); + xfer += (*(this->success))[_i760].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 _size762; - ::apache::thrift::protocol::TType _etype765; - xfer += iprot->readListBegin(_etype765, _size762); - this->success.resize(_size762); - uint32_t _i766; - for (_i766 = 0; _i766 < _size762; ++_i766) + uint32_t _size761; + ::apache::thrift::protocol::TType _etype764; + xfer += iprot->readListBegin(_etype764, _size761); + this->success.resize(_size761); + uint32_t _i765; + for (_i765 = 0; _i765 < _size761; ++_i765) { - xfer += this->success[_i766].read(iprot); + xfer += this->success[_i765].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 _iter767; - for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) + std::vector<FieldSchema> ::const_iterator _iter766; + for (_iter766 = this->success.begin(); _iter766 != this->success.end(); ++_iter766) { - xfer += (*_iter767).write(oprot); + xfer += (*_iter766).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 _size768; - ::apache::thrift::protocol::TType _etype771; - xfer += iprot->readListBegin(_etype771, _size768); - (*(this->success)).resize(_size768); - uint32_t _i772; - for (_i772 = 0; _i772 < _size768; ++_i772) + 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) { - xfer += (*(this->success))[_i772].read(iprot); + xfer += (*(this->success))[_i771].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 _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 _size772; + ::apache::thrift::protocol::TType _etype775; + xfer += iprot->readListBegin(_etype775, _size772); + this->success.resize(_size772); + uint32_t _i776; + for (_i776 = 0; _i776 < _size772; ++_i776) { - xfer += this->success[_i777].read(iprot); + xfer += this->success[_i776].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 _iter778; - for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) + std::vector<FieldSchema> ::const_iterator _iter777; + for (_iter777 = this->success.begin(); _iter777 != this->success.end(); ++_iter777) { - xfer += (*_iter778).write(oprot); + xfer += (*_iter777).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 _size779; - ::apache::thrift::protocol::TType _etype782; - xfer += iprot->readListBegin(_etype782, _size779); - (*(this->success)).resize(_size779); - uint32_t _i783; - for (_i783 = 0; _i783 < _size779; ++_i783) + 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) { - xfer += (*(this->success))[_i783].read(iprot); + xfer += (*(this->success))[_i782].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 _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 _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[_i788].read(iprot); + xfer += this->success[_i787].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 _iter789; - for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) + std::vector<FieldSchema> ::const_iterator _iter788; + for (_iter788 = this->success.begin(); _iter788 != this->success.end(); ++_iter788) { - xfer += (*_iter789).write(oprot); + xfer += (*_iter788).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 _size790; - ::apache::thrift::protocol::TType _etype793; - xfer += iprot->readListBegin(_etype793, _size790); - (*(this->success)).resize(_size790); - uint32_t _i794; - for (_i794 = 0; _i794 < _size790; ++_i794) + uint32_t _size789; + ::apache::thrift::protocol::TType _etype792; + xfer += iprot->readListBegin(_etype792, _size789); + (*(this->success)).resize(_size789); + uint32_t _i793; + for (_i793 = 0; _i793 < _size789; ++_i793) { - xfer += (*(this->success))[_i794].read(iprot); + xfer += (*(this->success))[_i793].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 _size795; - ::apache::thrift::protocol::TType _etype798; - xfer += iprot->readListBegin(_etype798, _size795); - this->success.resize(_size795); - uint32_t _i799; - for (_i799 = 0; _i799 < _size795; ++_i799) + 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[_i799]); + xfer += iprot->readString(this->success[_i798]); } 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 _iter800; - for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) + std::vector<std::string> ::const_iterator _iter799; + for (_iter799 = this->success.begin(); _iter799 != this->success.end(); ++_iter799) { - xfer += oprot->writeString((*_iter800)); + xfer += oprot->writeString((*_iter799)); } 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 _size801; - ::apache::thrift::protocol::TType _etype804; - xfer += iprot->readListBegin(_etype804, _size801); - (*(this->success)).resize(_size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size800; + ::apache::thrift::protocol::TType _etype803; + xfer += iprot->readListBegin(_etype803, _size800); + (*(this->success)).resize(_size800); + uint32_t _i804; + for (_i804 = 0; _i804 < _size800; ++_i804) { - xfer += iprot->readString((*(this->success))[_i805]); + xfer += iprot->readString((*(this->success))[_i804]); } 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 _size806; - ::apache::thrift::protocol::TType _etype809; - xfer += iprot->readListBegin(_etype809, _size806); - this->success.resize(_size806); - uint32_t _i810; - for (_i810 = 0; _i810 < _size806; ++_i810) + uint32_t _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readListBegin(_etype808, _size805); + this->success.resize(_size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) { - xfer += iprot->readString(this->success[_i810]); + xfer += iprot->readString(this->success[_i809]); } 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 _iter811; - for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811) + std::vector<std::string> ::const_iterator _iter810; + for (_iter810 = this->success.begin(); _iter810 != this->success.end(); ++_iter810) { - xfer += oprot->writeString((*_iter811)); + xfer += oprot->writeString((*_iter810)); } 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 _size812; - ::apache::thrift::protocol::TType _etype815; - xfer += iprot->readListBegin(_etype815, _size812); - (*(this->success)).resize(_size812); - uint32_t _i816; - for (_i816 = 0; _i816 < _size812; ++_i816) + uint32_t _size811; + ::apache::thrift::protocol::TType _etype814; + xfer += iprot->readListBegin(_etype814, _size811); + (*(this->success)).resize(_size811); + uint32_t _i815; + for (_i815 = 0; _i815 < _size811; ++_i815) { - xfer += iprot->readString((*(this->success))[_i816]); + xfer += iprot->readString((*(this->success))[_i815]); } 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 _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->tbl_names.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + uint32_t _size816; + ::apache::thrift::protocol::TType _etype819; + xfer += iprot->readListBegin(_etype819, _size816); + this->tbl_names.resize(_size816); + uint32_t _i820; + for (_i820 = 0; _i820 < _size816; ++_i820) { - xfer += iprot->readString(this->tbl_names[_i821]); + xfer += iprot->readString(this->tbl_names[_i820]); } 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 _iter822; - for (_iter822 = this->tbl_names.begin(); _iter822 != this->tbl_names.end(); ++_iter822) + std::vector<std::string> ::const_iterator _iter821; + for (_iter821 = this->tbl_names.begin(); _iter821 != this->tbl_names.end(); ++_iter821) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter821)); } 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 _iter823; - for (_iter823 = (*(this->tbl_names)).begin(); _iter823 != (*(this->tbl_names)).end(); ++_iter823) + std::vector<std::string> ::const_iterator _iter822; + for (_iter822 = (*(this->tbl_names)).begin(); _iter822 != (*(this->tbl_names)).end(); ++_iter822) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter822)); } 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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - this->success.resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + uint32_t _size823; + ::apache::thrift::protocol::TType _etype826; + xfer += iprot->readListBegin(_etype826, _size823); + this->success.resize(_size823); + uint32_t _i827; + for (_i827 = 0; _i827 < _size823; ++_i827) { - xfer += this->success[_i828].read(iprot); + xfer += this->success[_i827].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 _iter829; - for (_iter829 = this->success.begin(); _iter829 != this->success.end(); ++_iter829) + std::vector<Table> ::const_iterator _iter828; + for (_iter828 = this->success.begin(); _iter828 != this->success.end(); ++_iter828) { - xfer += (*_iter829).write(oprot); + xfer += (*_iter828).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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - (*(this->success)).resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size829; + ::apache::thrift::protocol::TType _etype832; + xfer += iprot->readListBegin(_etype832, _size829); + (*(this->success)).resize(_size829); + uint32_t _i833; + for (_i833 = 0; _i833 < _size829; ++_i833) { - xfer += (*(this->success))[_i834].read(iprot); + xfer += (*(this->success))[_i833].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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - this->success.resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + uint32_t _size834; + ::apache::thrift::protocol::TType _etype837; + xfer += iprot->readListBegin(_etype837, _size834); + this->success.resize(_size834); + uint32_t _i838; + for (_i838 = 0; _i838 < _size834; ++_i838) { - xfer += iprot->readString(this->success[_i839]); + xfer += iprot->readString(this->success[_i838]); } 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 _iter840; - for (_iter840 = this->success.begin(); _iter840 != this->success.end(); ++_iter840) + std::vector<std::string> ::const_iterator _iter839; + for (_iter839 = this->success.begin(); _iter839 != this->success.end(); ++_iter839) { - xfer += oprot->writeString((*_iter840)); + xfer += oprot->writeString((*_iter839)); } 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 _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - (*(this->success)).resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + uint32_t _size840; + ::apache::thrift::protocol::TType _etype843; + xfer += iprot->readListBegin(_etype843, _size840); + (*(this->success)).resize(_size840); + uint32_t _i844; + for (_i844 = 0; _i844 < _size840; ++_i844) { - xfer += iprot->readString((*(this->success))[_i845]); + xfer += iprot->readString((*(this->success))[_i844]); } 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 _size846; - ::apache::thrift::protocol::TType _etype849; - xfer += iprot->readListBegin(_etype849, _size846); - this->new_parts.resize(_size846); - uint32_t _i850; - for (_i850 = 0; _i850 < _size846; ++_i850) + uint32_t _size845; + ::apache::thrift::protocol::TType _etype848; + xfer += iprot->readListBegin(_etype848, _size845); + this->new_parts.resize(_size845); + uint32_t _i849; + for (_i849 = 0; _i849 < _size845; ++_i849) { - xfer += this->new_parts[_i850].read(iprot); + xfer += this->new_parts[_i849].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 _iter851; - for (_iter851 = this->new_parts.begin(); _iter851 != this->new_parts.end(); ++_iter851) + std::vector<Partition> ::const_iterator _iter850; + for (_iter850 = this->new_parts.begin(); _iter850 != this->new_parts.end(); ++_iter850) { - xfer += (*_iter851).write(oprot); + xfer += (*_iter850).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 _iter852; - for (_iter852 = (*(this->new_parts)).begin(); _iter852 != (*(this->new_parts)).end(); ++_iter852) + std::vector<Partition> ::const_iterator _iter851; + for (_iter851 = (*(this->new_parts)).begin(); _iter851 != (*(this->new_parts)).end(); ++_iter851) { - xfer += (*_iter852).write(oprot); + xfer += (*_iter851).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 _size853; - ::apache::thrift::protocol::TType _etype856; - xfer += iprot->readListBegin(_etype856, _size853); - this->new_parts.resize(_size853); - uint32_t _i857; - for (_i857 = 0; _i857 < _size853; ++_i857) + uint32_t _size852; + ::apache::thrift::protocol::TType _etype855; + xfer += iprot->readListBegin(_etype855, _size852); + this->new_parts.resize(_size852); + uint32_t _i856; + for (_i856 = 0; _i856 < _size852; ++_i856) { - xfer += this->new_parts[_i857].read(iprot); + xfer += this->new_parts[_i856].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 _iter858; - for (_iter858 = this->new_parts.begin(); _iter858 != this->new_parts.end(); ++_iter858) + std::vector<PartitionSpec> ::const_iterator _iter857; + for (_iter857 = this->new_parts.begin(); _iter857 != this->new_parts.end(); ++_iter857) { - xfer += (*_iter858).write(oprot); + xfer += (*_iter857).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 _iter859; - for (_iter859 = (*(this->new_parts)).begin(); _iter859 != (*(this->new_parts)).end(); ++_iter859) + std::vector<PartitionSpec> ::const_iterator _iter858; + for (_iter858 = (*(this->new_parts)).begin(); _iter858 != (*(this->new_parts)).end(); ++_iter858) { - xfer += (*_iter859).write(oprot); + xfer += (*_iter858).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 _size860; - ::apache::thrift::protocol::TType _etype863; - xfer += iprot->readListBegin(_etype863, _size860); - this->part_vals.resize(_size860); - uint32_t _i864; - for (_i864 = 0; _i864 < _size860; ++_i864) + uint32_t _size859; + ::apache::thrift::protocol::TType _etype862; + xfer += iprot->readListBegin(_etype862, _size859); + this->part_vals.resize(_size859); + uint32_t _i863; + for (_i863 = 0; _i863 < _size859; ++_i863) { - xfer += iprot->readString(this->part_vals[_i864]); + xfer += iprot->readString(this->part_vals[_i863]); } 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 _iter865; - for (_iter865 = this->part_vals.begin(); _iter865 != this->part_vals.end(); ++_iter865) + std::vector<std::string> ::const_iterator _iter864; + for (_iter864 = this->part_vals.begin(); _iter864 != this->part_vals.end(); ++_iter864) { - xfer += oprot->writeString((*_iter865)); + xfer += oprot->writeString((*_iter864)); } 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 _iter866; - for (_iter866 = (*(this->part_vals)).begin(); _iter866 != (*(this->part_vals)).end(); ++_iter866) + std::vector<std::string> ::const_iterator _iter865; + for (_iter865 = (*(this->part_vals)).begin(); _iter865 != (*(this->part_vals)).end(); ++_iter865) { - xfer += oprot->writeString((*_iter866)); + xfer += oprot->writeString((*_iter865)); } 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 _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 _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + this->part_vals.resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += iprot->readString(this->part_vals[_i871]); + xfer += iprot->readString(this->part_vals[_i870]); } 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 _iter872; - for (_iter872 = this->part_vals.begin(); _iter872 != this->part_vals.end(); ++_iter872) + std::vector<std::string> ::const_iterator _iter871; + for (_iter871 = this->part_vals.begin(); _iter871 != this->part_vals.end(); ++_iter871) { - xfer += oprot->writeString((*_iter872)); + xfer += oprot->writeString((*_iter871)); } 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 _iter873; - for (_iter873 = (*(this->part_vals)).begin(); _iter873 != (*(this->part_vals)).end(); ++_iter873) + std::vector<std::string> ::const_iterator _iter872; + for (_iter872 = (*(this->part_vals)).begin(); _iter872 != (*(this->part_vals)).end(); ++_iter872) { - xfer += oprot->writeString((*_iter873)); + xfer += oprot->writeString((*_iter872)); } 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 _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - this->part_vals.resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + uint32_t _size873; + ::apache::thrift::protocol::TType _etype876; + xfer += iprot->readListBegin(_etype876, _size873); + this->part_vals.resize(_size873); + uint32_t _i877; + for (_i877 = 0; _i877 < _size873; ++_i877) { - xfer += iprot->readString(this->part_vals[_i878]); + xfer += iprot->readString(this->part_vals[_i877]); } 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 _iter879; - for (_iter879 = this->part_vals.begin(); _iter879 != this->part_vals.end(); ++_iter879) + std::vector<std::string> ::const_iterator _iter878; + for (_iter878 = this->part_vals.begin(); _iter878 != this->part_vals.end(); ++_iter878) { - xfer += oprot->writeString((*_iter879)); + xfer += oprot->writeString((*_iter878)); } 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 _iter880; - for (_iter880 = (*(this->part_vals)).begin(); _iter880 != (*(this->part_vals)).end(); ++_iter880) + std::vector<std::string> ::const_iterator _iter879; + for (_iter879 = (*(this->part_vals)).begin(); _iter879 != (*(this->part_vals)).end(); ++_iter879) { - xfer += oprot->writeString((*_iter880)); + xfer += oprot->writeString((*_iter879)); } 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 _size881; - ::apache::thrift::protocol::TType _etype884; - xfer += iprot->readListBegin(_etype884, _size881); - this->part_vals.resize(_size881); - uint32_t _i885; - for (_i885 = 0; _i885 < _size881; ++_i885) + uint32_t _size880; + ::apache::thrift::protocol::TType _etype883; + xfer += iprot->readListBegin(_etype883, _size880); + this->part_vals.resize(_size880); + uint32_t _i884; + for (_i884 = 0; _i884 < _size880; ++_i884) { - xfer += iprot->readString(this->part_vals[_i885]); + xfer += iprot->readString(this->part_vals[_i884]); } 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 _iter886; - for (_iter886 = this->part_vals.begin(); _iter886 != this->part_vals.end(); ++_iter886) + std::vector<std::string> ::const_iterator _iter885; + for (_iter885 = this->part_vals.begin(); _iter885 != this->part_vals.end(); ++_iter885) { - xfer += oprot->writeString((*_iter886)); + xfer += oprot->writeString((*_iter885)); } 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 _iter887; - for (_iter887 = (*(this->part_vals)).begin(); _iter887 != (*(this->part_vals)).end(); ++_iter887) + std::vector<std::string> ::const_iterator _iter886; + for (_iter886 = (*(this->part_vals)).begin(); _iter886 != (*(this->part_vals)).end(); ++_iter886) { - xfer += oprot->writeString((*_iter887)); + xfer += oprot->writeString((*_iter886)); } 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 _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->part_vals.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->part_vals.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += iprot->readString(this->part_vals[_i892]); + xfer += iprot->readString(this->part_vals[_i891]); } 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 _iter893; - for (_iter893 = this->part_vals.begin(); _iter893 != this->part_vals.end(); ++_iter893) + std::vector<std::string> ::const_iterator _iter892; + for (_iter892 = this->part_vals.begin(); _iter892 != this->part_vals.end(); ++_iter892) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter892)); } 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 _iter894; - for (_iter894 = (*(this->part_vals)).begin(); _iter894 != (*(this->part_vals)).end(); ++_iter894) + std::vector<std::string> ::const_iterator _iter893; + for (_iter893 = (*(this->part_vals)).begin(); _iter893 != (*(this->part_vals)).end(); ++_iter893) { - xfer += oprot->writeString((*_iter894)); + xfer += oprot->writeString((*_iter893)); } 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 _size895; - ::apache::thrift::protocol::TType _ktype896; - ::apache::thrift::protocol::TType _vtype897; - xfer += iprot->readMapBegin(_ktype896, _vtype897, _size895); - uint32_t _i899; - for (_i899 = 0; _i899 < _size895; ++_i899) + uint32_t _size894; + ::apache::thrift::protocol::TType _ktype895; + ::apache::thrift::protocol::TType _vtype896; + xfer += iprot->readMapBegin(_ktype895, _vtype896, _size894); + uint32_t _i898; + for (_i898 = 0; _i898 < _size894; ++_i898) { - std::string _key900; - xfer += iprot->readString(_key900); - std::string& _val901 = this->partitionSpecs[_key900]; - xfer += iprot->readString(_val901); + std::string _key899; + xfer += iprot->readString(_key899); + std::string& _val900 = this->partitionSpecs[_key899]; + xfer += iprot->readString(_val900); } 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 _iter902; - for (_iter902 = this->partitionSpecs.begin(); _iter902 != this->partitionSpecs.end(); ++_iter902) + std::map<std::string, std::string> ::const_iterator _iter901; + for (_iter901 = this->partitionSpecs.begin(); _iter901 != this->partitionSpecs.end(); ++_iter901) { - xfer += oprot->writeString(_iter902->first); - xfer += oprot->writeString(_iter902->second); + xfer += oprot->writeString(_iter901->first); + xfer += oprot->writeString(_iter901->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 _iter903; - for (_iter903 = (*(this->partitionSpecs)).begin(); _iter903 != (*(this->partitionSpecs)).end(); ++_iter903) + std::map<std::string, std::string> ::const_iterator _iter902; + for (_iter902 = (*(this->partitionSpecs)).begin(); _iter902 != (*(this->partitionSpecs)).end(); ++_iter902) { - xfer += oprot->writeString(_iter903->first); - xfer += oprot->writeString(_iter903->second); + xfer += oprot->writeString(_iter902->first); + xfer += oprot->writeString(_iter902->second); } xfer += oprot->writeMapEnd(); } @@ -11717,14 +11717,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 _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->part_vals.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size903; + ::apache::thrift::protocol::TType _etype906; + xfer += iprot->readListBegin(_etype906, _size903); + this->part_vals.resize(_size903); + uint32_t _i907; + for (_i907 = 0; _i907 < _size903; ++_i907) { - xfer += iprot->readString(this->part_vals[_i908]); + xfer += iprot->readString(this->part_vals[_i907]); } xfer += iprot->readListEnd(); } @@ -11745,14 +11745,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 _size909; - ::apache::thrift::protocol::TType _etype912; - xfer += iprot->readListBegin(_etype912, _size909); - this->group_names.resize(_size909); - uint32_t _i913; - for (_i913 = 0; _i913 < _size909; ++_i913) + uint32_t _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + this->group_names.resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString(this->group_names[_i913]); + xfer += iprot->readString(this->group_names[_i912]); } xfer += iprot->readListEnd(); } @@ -11789,10 +11789,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 _iter914; - for (_iter914 = this->part_vals.begin(); _iter914 != this->part_vals.end(); ++_iter914) + std::vector<std::string> ::const_iterator _iter913; + for (_iter913 = this->part_vals.begin(); _iter913 != this->part_vals.end(); ++_iter913) { - xfer += oprot->writeString((*_iter914)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -11805,10 +11805,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 _iter915; - for (_iter915 = this->group_names.begin(); _iter915 != this->group_names.end(); ++_iter915) + std::vector<std::string> ::const_iterator _iter914; + for (_iter914 = this->group_names.begin(); _iter914 != this->group_names.end(); ++_iter914) { - xfer += oprot->writeString((*_iter915)); + xfer += oprot->writeString((*_iter914)); } xfer += oprot->writeListEnd(); } @@ -11840,10 +11840,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 _iter916; - for (_iter916 = (*(this->part_vals)).begin(); _iter916 != (*(this->part_vals)).end(); ++_iter916) + std::vector<std::string> ::const_iterator _iter915; + for (_iter915 = (*(this->part_vals)).begin(); _iter915 != (*(this->part_vals)).end(); ++_iter915) { - xfer += oprot->writeString((*_iter916)); + xfer += oprot->writeString((*_iter915)); } xfer += oprot->writeListEnd(); } @@ -11856,10 +11856,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 _iter917; - for (_iter917 = (*(this->group_names)).begin(); _iter917 != (*(this->group_names)).end(); ++_iter917) + std::vector<std::string> ::const_iterator _iter916; + for (_iter916 = (*(this->group_names)).begin(); _iter916 != (*(this->group_names)).end(); ++_iter916) { - xfer += oprot->writeString((*_iter917)); + xfer += oprot->writeString((*_iter916)); } xfer += oprot->writeListEnd(); } @@ -12418,14 +12418,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto 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 _size917; + ::apache::thrift::protocol::TType _etype920; + xfer += iprot->readListBegin(_etype920, _size917); + this->success.resize(_size917); + uint32_t _i921; + for (_i921 = 0; _i921 < _size917; ++_i921) { - xfer += this->success[_i922].read(iprot); + xfer += this->success[_i921].read(iprot); } xfer += iprot->readListEnd(); } @@ -12472,10 +12472,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 _iter923; - for (_iter923 = this->success.begin(); _iter923 != this->success.end(); ++_iter923) + std::vector<Partition> ::const_iterator _iter922; + for (_iter922 = this->success.begin(); _iter922 != this->success.end(); ++_iter922) { - xfer += (*_iter923).write(oprot); + xfer += (*_iter922).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12524,14 +12524,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - (*(this->success)).resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + 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 += (*(this->success))[_i928].read(iprot); + xfer += (*(this->success))[_i927].read(iprot); } xfer += iprot->readListEnd(); } @@ -12630,14 +12630,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 _size929; - ::apache::thrift::protocol::TType _etype932; - xfer += iprot->readListBegin(_etype932, _size929); - this->group_names.resize(_size929); - uint32_t _i933; - for (_i933 = 0; _i933 < _size929; ++_i933) + uint32_t _size928; + ::apache::thrift::protocol::TType _etype931; + xfer += iprot->readListBegin(_etype931, _size928); + this->group_names.resize(_size928); + uint32_t _i932; + for (_i932 = 0; _i932 < _size928; ++_i932) { - xfer += iprot->readString(this->group_names[_i933]); + xfer += iprot->readString(this->group_names[_i932]); } xfer += iprot->readListEnd(); } @@ -12682,10 +12682,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 _iter934; - for (_iter934 = this->group_names.begin(); _iter934 != this->group_names.end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter933; + for (_iter933 = this->group_names.begin(); _iter933 != this->group_names.end(); ++_iter933) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter933)); } xfer += oprot->writeListEnd(); } @@ -12725,10 +12725,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 _iter935; - for (_iter935 = (*(this->group_names)).begin(); _iter935 != (*(this->group_names)).end(); ++_iter935) + std::vector<std::string> ::const_iterator _iter934; + for (_iter934 = (*(this->group_names)).begin(); _iter934 != (*(this->group_names)).end(); ++_iter934) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter934)); } xfer += oprot->writeListEnd(); } @@ -12769,14 +12769,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size936; - ::apache::thrift::protocol::TType _etype939; - xfer += iprot->readListBegin(_etype939, _size936); - this->success.resize(_size936); - uint32_t _i940; - for (_i940 = 0; _i940 < _size936; ++_i940) + uint32_t _size935; + ::apache::thrift::protocol::TType _etype938; + xfer += iprot->readListBegin(_etype938, _size935); + this->success.resize(_size935); + uint32_t _i939; + for (_i939 = 0; _i939 < _size935; ++_i939) { - xfer += this->success[_i940].read(iprot); + xfer += this->success[_i939].read(iprot); } xfer += iprot->readListEnd(); } @@ -12823,10 +12823,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 _iter941; - for (_iter941 = this->success.begin(); _iter941 != this->success.end(); ++_iter941) + std::vector<Partition> ::const_iterator _iter940; + for (_iter940 = this->success.begin(); _iter940 != this->success.end(); ++_iter940) { - xfer += (*_iter941).write(oprot); + xfer += (*_iter940).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12875,14 +12875,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - (*(this->success)).resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + 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))[_i946].read(iprot); + xfer += (*(this->success))[_i945].read(iprot); } xfer += iprot->readListEnd(); } @@ -13060,14 +13060,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: 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 _size946; + ::apache::thrift::protocol::TType _etype949; + xfer += iprot->readListBegin(_etype949, _size946); + this->success.resize(_size946); + uint32_t _i950; + for (_i950 = 0; _i950 < _size946; ++_i950) { - xfer += this->success[_i951].read(iprot); + xfer += this->success[_i950].read(iprot); } xfer += iprot->readListEnd(); } @@ -13114,10 +13114,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 _iter952; - for (_iter952 = this->success.begin(); _iter952 != this->success.end(); ++_iter952) + std::vector<PartitionSpec> ::const_iterator _iter951; + for (_iter951 = this->success.begin(); _iter951 != this->success.end(); ++_iter951) { - xfer += (*_iter952).write(oprot); + xfer += (*_iter951).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13166,14 +13166,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - (*(this->success)).resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size952; + ::apache::thrift::protocol::TType _etype955; + xfer += iprot->readListBegin(_etype955, _size952); + (*(this->success)).resize(_size952); + uint32_t _i956; + for (_i956 = 0; _i956 < _size952; ++_i956) { - xfer += (*(this->success))[_i957].read(iprot); + xfer += (*(this->success))[_i956].read(iprot); } xfer += iprot->readListEnd(); } @@ -13351,14 +13351,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size958; - ::apache::thrift::protocol::TType _etype961; - xfer += iprot->readListBegin(_etype961, _size958); - this->success.resize(_size958); - uint32_t _i962; - for (_i962 = 0; _i962 < _size958; ++_i962) + uint32_t _size957; + ::apache::thrift::protocol::TType _etype960; + xfer += iprot->readListBegin(_etype960, _size957); + this->success.resize(_size957); + uint32_t _i961; + for (_i961 = 0; _i961 < _size957; ++_i961) { - xfer += iprot->readString(this->success[_i962]); + xfer += iprot->readString(this->success[_i961]); } xfer += iprot->readListEnd(); } @@ -13397,10 +13397,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 _iter963; - for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter962; + for (_iter962 = this->success.begin(); _iter962 != this->success.end(); ++_iter962) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter962)); } xfer += oprot->writeListEnd(); } @@ -13445,14 +13445,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - (*(this->success)).resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size963; + ::apache::thrift::protocol::TType _etype966; + xfer += iprot->readListBegin(_etype966, _size963); + (*(this->success)).resize(_size963); + uint32_t _i967; + for (_i967 = 0; _i967 < _size963; ++_i967) { - xfer += iprot->readString((*(this->success))[_i968]); + xfer += iprot->readString((*(this->success))[_i967]); } xfer += iprot->readListEnd(); } @@ -13527,14 +13527,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 _size969; - ::apache::thrift::protocol::TType _etype972; - xfer += iprot->readListBegin(_etype972, _size969); - this->part_vals.resize(_size969); - uint32_t _i973; - for (_i973 = 0; _i973 < _size969; ++_i973) + uint32_t _size968; + ::apache::thrift::protocol::TType _etype971; + xfer += iprot->readListBegin(_etype971, _size968); + this->part_vals.resize(_size968); + uint32_t _i972; + for (_i972 = 0; _i972 < _size968; ++_i972) { - xfer += iprot->readString(this->part_vals[_i973]); + xfer += iprot->readString(this->part_vals[_i972]); } xfer += iprot->readListEnd(); } @@ -13579,10 +13579,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 _iter974; - for (_iter974 = this->part_vals.begin(); _iter974 != this->part_vals.end(); ++_iter974) + std::vector<std::string> ::const_iterator _iter973; + for (_iter973 = this->part_vals.begin(); _iter973 != this->part_vals.end(); ++_iter973) { - xfer += oprot->writeString((*_iter974)); + xfer += oprot->writeString((*_iter973)); } xfer += oprot->writeListEnd(); } @@ -13618,10 +13618,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 _iter975; - for (_iter975 = (*(this->part_vals)).begin(); _iter975 != (*(this->part_vals)).end(); ++_iter975) + std::vector<std::string> ::const_iterator _iter974; + for (_iter974 = (*(this->part_vals)).begin(); _iter974 != (*(this->part_vals)).end(); ++_iter974) { - xfer += oprot->writeString((*_iter975)); + xfer += oprot->writeString((*_iter974)); } xfer += oprot->writeListEnd(); } @@ -13666,14 +13666,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size976; - ::apache::thrift::protocol::TType _etype979; - xfer += iprot->readListBegin(_etype979, _size976); - this->success.resize(_size976); - uint32_t _i980; - for (_i980 = 0; _i980 < _size976; ++_i980) + uint32_t _size975; + ::apache::thrift::protocol::TType _etype978; + xfer += iprot->readListBegin(_etype978, _size975); + this->success.resize(_size975); + uint32_t _i979; + for (_i979 = 0; _i979 < _size975; ++_i979) { - xfer += this->success[_i980].read(iprot); + xfer += this->success[_i979].read(iprot); } xfer += iprot->readListEnd(); } @@ -13720,10 +13720,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 _iter981; - for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) + std::vector<Partition> ::const_iterator _iter980; + for (_iter980 = this->success.begin(); _iter980 != this->success.end(); ++_iter980) { - xfer += (*_iter981).write(oprot); + xfer += (*_iter980).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13772,14 +13772,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - (*(this->success)).resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size981; + ::apache::thrift::protocol::TType _etype984; + xfer += iprot->readListBegin(_etype984, _size981); + (*(this->success)).resize(_size981); + uint32_t _i985; + for (_i985 = 0; _i985 < _size981; ++_i985) { - xfer += (*(this->success))[_i986].read(iprot); + xfer += (*(this->success))[_i985].read(iprot); } xfer += iprot->readListEnd(); } @@ -13862,14 +13862,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 _size987; - ::apache::thrift::protocol::TType _etype990; - xfer += iprot->readListBegin(_etype990, _size987); - this->part_vals.resize(_size987); - uint32_t _i991; - for (_i991 = 0; _i991 < _size987; ++_i991) + uint32_t _size986; + ::apache::thrift::protocol::TType _etype989; + xfer += iprot->readListBegin(_etype989, _size986); + this->part_vals.resize(_size986); + uint32_t _i990; + for (_i990 = 0; _i990 < _size986; ++_i990) { - xfer += iprot->readString(this->part_vals[_i991]); + xfer += iprot->readString(this->part_vals[_i990]); } xfer += iprot->readListEnd(); } @@ -13898,14 +13898,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 _size992; - ::apache::thrift::protocol::TType _etype995; - xfer += iprot->readListBegin(_etype995, _size992); - this->group_names.resize(_size992); - uint32_t _i996; - for (_i996 = 0; _i996 < _size992; ++_i996) + uint32_t _size991; + ::apache::thrift::protocol::TType _etype994; + xfer += iprot->readListBegin(_etype994, _size991); + this->group_names.resize(_size991); + uint32_t _i995; + for (_i995 = 0; _i995 < _size991; ++_i995) { - xfer += iprot->readString(this->group_names[_i996]); + xfer += iprot->readString(this->group_names[_i995]); } xfer += iprot->readListEnd(); } @@ -13942,10 +13942,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 _iter997; - for (_iter997 = this->part_vals.begin(); _iter997 != this->part_vals.end(); ++_iter997) + std::vector<std::string> ::const_iterator _iter996; + for (_iter996 = this->part_vals.begin(); _iter996 != this->part_vals.end(); ++_iter996) { - xfer += oprot->writeString((*_iter997)); + xfer += oprot->writeString((*_iter996)); } xfer += oprot->writeListEnd(); } @@ -13962,10 +13962,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 _iter998; - for (_iter998 = this->group_names.begin(); _iter998 != this->group_names.end(); ++_iter998) + std::vector<std::string> ::const_iterator _iter997; + for (_iter997 = this->group_names.begin(); _iter997 != this->group_names.end(); ++_iter997) { - xfer += oprot->writeString((*_iter998)); + xfer += oprot->writeString((*_iter997)); } xfer += oprot->writeListEnd(); } @@ -13997,10 +13997,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter999; - for (_iter999 = (*(this->part_vals)).begin(); _iter999 != (*(this->part_vals)).end(); ++_iter999) + std::vector<std::string> ::const_iterator _iter998; + for (_iter998 = (*(this->part_vals)).begin(); _iter998 != (*(this->part_vals)).end(); ++_iter998) { - xfer += oprot->writeString((*_iter999)); + xfer += oprot->writeString((*_iter998)); } xfer += oprot->writeListEnd(); } @@ -14017,10 +14017,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1000; - for (_iter1000 = (*(this->group_names)).begin(); _iter1000 != (*(this->group_names)).end(); ++_iter1000) + std::vector<std::string> ::const_iterator _iter999; + for (_iter999 = (*(this->group_names)).begin(); _iter999 != (*(this->group_names)).end(); ++_iter999) { - xfer += oprot->writeString((*_iter1000)); + xfer += oprot->writeString((*_iter999)); } xfer += oprot->writeListEnd(); } @@ -14061,14 +14061,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1001; - ::apache::thrift::protocol::TType _etype1004; - xfer += iprot->readListBegin(_etype1004, _size1001); - this->success.resize(_size1001); - uint32_t _i1005; - for (_i1005 = 0; _i1005 < _size1001; ++_i1005) + uint32_t _size1000; + ::apache::thrift::protocol::TType _etype1003; + xfer += iprot->readListBegin(_etype1003, _size1000); + this->success.resize(_size1000); + uint32_t _i1004; + for (_i1004 = 0; _i1004 < _size1000; ++_i1004) { - xfer += this->success[_i1005].read(iprot); + xfer += this->success[_i1004].read(iprot); } xfer += iprot->readListEnd(); } @@ -14115,10 +14115,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1006; - for (_iter1006 = this->success.begin(); _iter1006 != this->success.end(); ++_iter1006) + std::vector<Partition> ::const_iterator _iter1005; + for (_iter1005 = this->success.begin(); _iter1005 != this->success.end(); ++_iter1005) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1005).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14167,14 +14167,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - (*(this->success)).resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1006; + ::apache::thrift::protocol::TType _etype1009; + xfer += iprot->readListBegin(_etype1009, _size1006); + (*(this->success)).resize(_size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - xfer += (*(this->success))[_i1011].read(iprot); + xfer += (*(this->success))[_i1010].read(iprot); } xfer += iprot->readListEnd(); } @@ -14257,14 +14257,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1012; - ::apache::thrift::protocol::TType _etype1015; - xfer += iprot->readListBegin(_etype1015, _size1012); - this->part_vals.resize(_size1012); - uint32_t _i1016; - for (_i1016 = 0; _i1016 < _size1012; ++_i1016) + uint32_t _size1011; + ::apache::thrift::protocol::TType _etype1014; + xfer += iprot->readListBegin(_etype1014, _size1011); + this->part_vals.resize(_size1011); + uint32_t _i1015; + for (_i1015 = 0; _i1015 < _size1011; ++_i1015) { - xfer += iprot->readString(this->part_vals[_i1016]); + xfer += iprot->readString(this->part_vals[_i1015]); } xfer += iprot->readListEnd(); } @@ -14309,10 +14309,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1017; - for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017) + std::vector<std::string> ::const_iterator _iter1016; + for (_iter1016 = this->part_vals.begin(); _iter1016 != this->part_vals.end(); ++_iter1016) { - xfer += oprot->writeString((*_iter1017)); + xfer
<TRUNCATED>
