http://git-wip-us.apache.org/repos/asf/hive/blob/6d4aa068/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 4d108de..bc84e20 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1235,14 +1235,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size713; - ::apache::thrift::protocol::TType _etype716; - xfer += iprot->readListBegin(_etype716, _size713); - this->success.resize(_size713); - uint32_t _i717; - for (_i717 = 0; _i717 < _size713; ++_i717) + uint32_t _size714; + ::apache::thrift::protocol::TType _etype717; + xfer += iprot->readListBegin(_etype717, _size714); + this->success.resize(_size714); + uint32_t _i718; + for (_i718 = 0; _i718 < _size714; ++_i718) { - xfer += iprot->readString(this->success[_i717]); + xfer += iprot->readString(this->success[_i718]); } xfer += iprot->readListEnd(); } @@ -1281,10 +1281,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 _iter718; - for (_iter718 = this->success.begin(); _iter718 != this->success.end(); ++_iter718) + std::vector<std::string> ::const_iterator _iter719; + for (_iter719 = this->success.begin(); _iter719 != this->success.end(); ++_iter719) { - xfer += oprot->writeString((*_iter718)); + xfer += oprot->writeString((*_iter719)); } xfer += oprot->writeListEnd(); } @@ -1328,14 +1328,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += iprot->readString((*(this->success))[_i723]); + xfer += iprot->readString((*(this->success))[_i724]); } xfer += iprot->readListEnd(); } @@ -1452,14 +1452,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size724; - ::apache::thrift::protocol::TType _etype727; - xfer += iprot->readListBegin(_etype727, _size724); - this->success.resize(_size724); - uint32_t _i728; - for (_i728 = 0; _i728 < _size724; ++_i728) + uint32_t _size725; + ::apache::thrift::protocol::TType _etype728; + xfer += iprot->readListBegin(_etype728, _size725); + this->success.resize(_size725); + uint32_t _i729; + for (_i729 = 0; _i729 < _size725; ++_i729) { - xfer += iprot->readString(this->success[_i728]); + xfer += iprot->readString(this->success[_i729]); } xfer += iprot->readListEnd(); } @@ -1498,10 +1498,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 _iter729; - for (_iter729 = this->success.begin(); _iter729 != this->success.end(); ++_iter729) + std::vector<std::string> ::const_iterator _iter730; + for (_iter730 = this->success.begin(); _iter730 != this->success.end(); ++_iter730) { - xfer += oprot->writeString((*_iter729)); + xfer += oprot->writeString((*_iter730)); } xfer += oprot->writeListEnd(); } @@ -1545,14 +1545,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += iprot->readString((*(this->success))[_i734]); + xfer += iprot->readString((*(this->success))[_i735]); } xfer += iprot->readListEnd(); } @@ -2610,17 +2610,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - 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) + 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) { - std::string _key740; - xfer += iprot->readString(_key740); - Type& _val741 = this->success[_key740]; - xfer += _val741.read(iprot); + std::string _key741; + xfer += iprot->readString(_key741); + Type& _val742 = this->success[_key741]; + xfer += _val742.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2659,11 +2659,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 _iter742; - for (_iter742 = this->success.begin(); _iter742 != this->success.end(); ++_iter742) + std::map<std::string, Type> ::const_iterator _iter743; + for (_iter743 = this->success.begin(); _iter743 != this->success.end(); ++_iter743) { - xfer += oprot->writeString(_iter742->first); - xfer += _iter742->second.write(oprot); + xfer += oprot->writeString(_iter743->first); + xfer += _iter743->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2707,17 +2707,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - 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) + 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) { - std::string _key748; - xfer += iprot->readString(_key748); - Type& _val749 = (*(this->success))[_key748]; - xfer += _val749.read(iprot); + std::string _key749; + xfer += iprot->readString(_key749); + Type& _val750 = (*(this->success))[_key749]; + xfer += _val750.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2871,14 +2871,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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 += this->success[_i754].read(iprot); + xfer += this->success[_i755].read(iprot); } xfer += iprot->readListEnd(); } @@ -2933,10 +2933,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 _iter755; - for (_iter755 = this->success.begin(); _iter755 != this->success.end(); ++_iter755) + std::vector<FieldSchema> ::const_iterator _iter756; + for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) { - xfer += (*_iter755).write(oprot); + xfer += (*_iter756).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2988,14 +2988,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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 += (*(this->success))[_i760].read(iprot); + xfer += (*(this->success))[_i761].read(iprot); } xfer += iprot->readListEnd(); } @@ -3181,14 +3181,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i765].read(iprot); + xfer += this->success[_i766].read(iprot); } xfer += iprot->readListEnd(); } @@ -3243,10 +3243,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 _iter766; - for (_iter766 = this->success.begin(); _iter766 != this->success.end(); ++_iter766) + std::vector<FieldSchema> ::const_iterator _iter767; + for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) { - xfer += (*_iter766).write(oprot); + xfer += (*_iter767).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3298,14 +3298,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: 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 _size768; + ::apache::thrift::protocol::TType _etype771; + xfer += iprot->readListBegin(_etype771, _size768); + (*(this->success)).resize(_size768); + uint32_t _i772; + for (_i772 = 0; _i772 < _size768; ++_i772) { - xfer += (*(this->success))[_i771].read(iprot); + xfer += (*(this->success))[_i772].read(iprot); } xfer += iprot->readListEnd(); } @@ -3475,14 +3475,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i776].read(iprot); + xfer += this->success[_i777].read(iprot); } xfer += iprot->readListEnd(); } @@ -3537,10 +3537,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 _iter777; - for (_iter777 = this->success.begin(); _iter777 != this->success.end(); ++_iter777) + std::vector<FieldSchema> ::const_iterator _iter778; + for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) { - xfer += (*_iter777).write(oprot); + xfer += (*_iter778).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3592,14 +3592,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol 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 _size779; + ::apache::thrift::protocol::TType _etype782; + xfer += iprot->readListBegin(_etype782, _size779); + (*(this->success)).resize(_size779); + uint32_t _i783; + for (_i783 = 0; _i783 < _size779; ++_i783) { - xfer += (*(this->success))[_i782].read(iprot); + xfer += (*(this->success))[_i783].read(iprot); } xfer += iprot->readListEnd(); } @@ -3785,14 +3785,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i787].read(iprot); + xfer += this->success[_i788].read(iprot); } xfer += iprot->readListEnd(); } @@ -3847,10 +3847,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 _iter788; - for (_iter788 = this->success.begin(); _iter788 != this->success.end(); ++_iter788) + std::vector<FieldSchema> ::const_iterator _iter789; + for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) { - xfer += (*_iter788).write(oprot); + xfer += (*_iter789).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3902,14 +3902,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += (*(this->success))[_i793].read(iprot); + xfer += (*(this->success))[_i794].read(iprot); } xfer += iprot->readListEnd(); } @@ -5079,14 +5079,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i798]); + xfer += iprot->readString(this->success[_i799]); } xfer += iprot->readListEnd(); } @@ -5125,10 +5125,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 _iter799; - for (_iter799 = this->success.begin(); _iter799 != this->success.end(); ++_iter799) + std::vector<std::string> ::const_iterator _iter800; + for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) { - xfer += oprot->writeString((*_iter799)); + xfer += oprot->writeString((*_iter800)); } xfer += oprot->writeListEnd(); } @@ -5172,14 +5172,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += iprot->readString((*(this->success))[_i804]); + xfer += iprot->readString((*(this->success))[_i805]); } xfer += iprot->readListEnd(); } @@ -5317,14 +5317,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i809]); + xfer += iprot->readString(this->success[_i810]); } xfer += iprot->readListEnd(); } @@ -5363,10 +5363,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 _iter810; - for (_iter810 = this->success.begin(); _iter810 != this->success.end(); ++_iter810) + std::vector<std::string> ::const_iterator _iter811; + for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811) { - xfer += oprot->writeString((*_iter810)); + xfer += oprot->writeString((*_iter811)); } xfer += oprot->writeListEnd(); } @@ -5410,14 +5410,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += iprot->readString((*(this->success))[_i815]); + xfer += iprot->readString((*(this->success))[_i816]); } xfer += iprot->readListEnd(); } @@ -5725,14 +5725,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 _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) + 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) { - xfer += iprot->readString(this->tbl_names[_i820]); + xfer += iprot->readString(this->tbl_names[_i821]); } xfer += iprot->readListEnd(); } @@ -5765,10 +5765,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 _iter821; - for (_iter821 = this->tbl_names.begin(); _iter821 != this->tbl_names.end(); ++_iter821) + std::vector<std::string> ::const_iterator _iter822; + for (_iter822 = this->tbl_names.begin(); _iter822 != this->tbl_names.end(); ++_iter822) { - xfer += oprot->writeString((*_iter821)); + xfer += oprot->writeString((*_iter822)); } xfer += oprot->writeListEnd(); } @@ -5797,10 +5797,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 _iter822; - for (_iter822 = (*(this->tbl_names)).begin(); _iter822 != (*(this->tbl_names)).end(); ++_iter822) + std::vector<std::string> ::const_iterator _iter823; + for (_iter823 = (*(this->tbl_names)).begin(); _iter823 != (*(this->tbl_names)).end(); ++_iter823) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter823)); } xfer += oprot->writeListEnd(); } @@ -5841,14 +5841,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 _size823; - ::apache::thrift::protocol::TType _etype826; - xfer += iprot->readListBegin(_etype826, _size823); - this->success.resize(_size823); - uint32_t _i827; - for (_i827 = 0; _i827 < _size823; ++_i827) + 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) { - xfer += this->success[_i827].read(iprot); + xfer += this->success[_i828].read(iprot); } xfer += iprot->readListEnd(); } @@ -5903,10 +5903,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 _iter828; - for (_iter828 = this->success.begin(); _iter828 != this->success.end(); ++_iter828) + std::vector<Table> ::const_iterator _iter829; + for (_iter829 = this->success.begin(); _iter829 != this->success.end(); ++_iter829) { - xfer += (*_iter828).write(oprot); + xfer += (*_iter829).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5958,14 +5958,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 _size829; - ::apache::thrift::protocol::TType _etype832; - xfer += iprot->readListBegin(_etype832, _size829); - (*(this->success)).resize(_size829); - uint32_t _i833; - for (_i833 = 0; _i833 < _size829; ++_i833) + 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) { - xfer += (*(this->success))[_i833].read(iprot); + xfer += (*(this->success))[_i834].read(iprot); } xfer += iprot->readListEnd(); } @@ -6151,14 +6151,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 _size834; - ::apache::thrift::protocol::TType _etype837; - xfer += iprot->readListBegin(_etype837, _size834); - this->success.resize(_size834); - uint32_t _i838; - for (_i838 = 0; _i838 < _size834; ++_i838) + 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) { - xfer += iprot->readString(this->success[_i838]); + xfer += iprot->readString(this->success[_i839]); } xfer += iprot->readListEnd(); } @@ -6213,10 +6213,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 _iter839; - for (_iter839 = this->success.begin(); _iter839 != this->success.end(); ++_iter839) + std::vector<std::string> ::const_iterator _iter840; + for (_iter840 = this->success.begin(); _iter840 != this->success.end(); ++_iter840) { - xfer += oprot->writeString((*_iter839)); + xfer += oprot->writeString((*_iter840)); } xfer += oprot->writeListEnd(); } @@ -6268,14 +6268,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 _size840; - ::apache::thrift::protocol::TType _etype843; - xfer += iprot->readListBegin(_etype843, _size840); - (*(this->success)).resize(_size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + 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) { - xfer += iprot->readString((*(this->success))[_i844]); + xfer += iprot->readString((*(this->success))[_i845]); } xfer += iprot->readListEnd(); } @@ -7603,14 +7603,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - 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) + 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) { - xfer += this->new_parts[_i849].read(iprot); + xfer += this->new_parts[_i850].read(iprot); } xfer += iprot->readListEnd(); } @@ -7639,10 +7639,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 _iter850; - for (_iter850 = this->new_parts.begin(); _iter850 != this->new_parts.end(); ++_iter850) + std::vector<Partition> ::const_iterator _iter851; + for (_iter851 = this->new_parts.begin(); _iter851 != this->new_parts.end(); ++_iter851) { - xfer += (*_iter850).write(oprot); + xfer += (*_iter851).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7667,10 +7667,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 _iter851; - for (_iter851 = (*(this->new_parts)).begin(); _iter851 != (*(this->new_parts)).end(); ++_iter851) + std::vector<Partition> ::const_iterator _iter852; + for (_iter852 = (*(this->new_parts)).begin(); _iter852 != (*(this->new_parts)).end(); ++_iter852) { - xfer += (*_iter851).write(oprot); + xfer += (*_iter852).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7877,14 +7877,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 _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) + 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) { - xfer += this->new_parts[_i856].read(iprot); + xfer += this->new_parts[_i857].read(iprot); } xfer += iprot->readListEnd(); } @@ -7913,10 +7913,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 _iter857; - for (_iter857 = this->new_parts.begin(); _iter857 != this->new_parts.end(); ++_iter857) + std::vector<PartitionSpec> ::const_iterator _iter858; + for (_iter858 = this->new_parts.begin(); _iter858 != this->new_parts.end(); ++_iter858) { - xfer += (*_iter857).write(oprot); + xfer += (*_iter858).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7941,10 +7941,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 _iter858; - for (_iter858 = (*(this->new_parts)).begin(); _iter858 != (*(this->new_parts)).end(); ++_iter858) + std::vector<PartitionSpec> ::const_iterator _iter859; + for (_iter859 = (*(this->new_parts)).begin(); _iter859 != (*(this->new_parts)).end(); ++_iter859) { - xfer += (*_iter858).write(oprot); + xfer += (*_iter859).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8167,14 +8167,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + 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) { - xfer += iprot->readString(this->part_vals[_i863]); + xfer += iprot->readString(this->part_vals[_i864]); } xfer += iprot->readListEnd(); } @@ -8211,10 +8211,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 _iter864; - for (_iter864 = this->part_vals.begin(); _iter864 != this->part_vals.end(); ++_iter864) + std::vector<std::string> ::const_iterator _iter865; + for (_iter865 = this->part_vals.begin(); _iter865 != this->part_vals.end(); ++_iter865) { - xfer += oprot->writeString((*_iter864)); + xfer += oprot->writeString((*_iter865)); } xfer += oprot->writeListEnd(); } @@ -8247,10 +8247,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 _iter865; - for (_iter865 = (*(this->part_vals)).begin(); _iter865 != (*(this->part_vals)).end(); ++_iter865) + std::vector<std::string> ::const_iterator _iter866; + for (_iter866 = (*(this->part_vals)).begin(); _iter866 != (*(this->part_vals)).end(); ++_iter866) { - xfer += oprot->writeString((*_iter865)); + xfer += oprot->writeString((*_iter866)); } xfer += oprot->writeListEnd(); } @@ -8719,14 +8719,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + 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) { - xfer += iprot->readString(this->part_vals[_i870]); + xfer += iprot->readString(this->part_vals[_i871]); } xfer += iprot->readListEnd(); } @@ -8771,10 +8771,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 _iter871; - for (_iter871 = this->part_vals.begin(); _iter871 != this->part_vals.end(); ++_iter871) + std::vector<std::string> ::const_iterator _iter872; + for (_iter872 = this->part_vals.begin(); _iter872 != this->part_vals.end(); ++_iter872) { - xfer += oprot->writeString((*_iter871)); + xfer += oprot->writeString((*_iter872)); } xfer += oprot->writeListEnd(); } @@ -8811,10 +8811,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 _iter872; - for (_iter872 = (*(this->part_vals)).begin(); _iter872 != (*(this->part_vals)).end(); ++_iter872) + std::vector<std::string> ::const_iterator _iter873; + for (_iter873 = (*(this->part_vals)).begin(); _iter873 != (*(this->part_vals)).end(); ++_iter873) { - xfer += oprot->writeString((*_iter872)); + xfer += oprot->writeString((*_iter873)); } xfer += oprot->writeListEnd(); } @@ -9613,14 +9613,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + 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) { - xfer += iprot->readString(this->part_vals[_i877]); + xfer += iprot->readString(this->part_vals[_i878]); } xfer += iprot->readListEnd(); } @@ -9665,10 +9665,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 _iter878; - for (_iter878 = this->part_vals.begin(); _iter878 != this->part_vals.end(); ++_iter878) + std::vector<std::string> ::const_iterator _iter879; + for (_iter879 = this->part_vals.begin(); _iter879 != this->part_vals.end(); ++_iter879) { - xfer += oprot->writeString((*_iter878)); + xfer += oprot->writeString((*_iter879)); } xfer += oprot->writeListEnd(); } @@ -9705,10 +9705,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 _iter879; - for (_iter879 = (*(this->part_vals)).begin(); _iter879 != (*(this->part_vals)).end(); ++_iter879) + std::vector<std::string> ::const_iterator _iter880; + for (_iter880 = (*(this->part_vals)).begin(); _iter880 != (*(this->part_vals)).end(); ++_iter880) { - xfer += oprot->writeString((*_iter879)); + xfer += oprot->writeString((*_iter880)); } xfer += oprot->writeListEnd(); } @@ -9915,14 +9915,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + 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) { - xfer += iprot->readString(this->part_vals[_i884]); + xfer += iprot->readString(this->part_vals[_i885]); } xfer += iprot->readListEnd(); } @@ -9975,10 +9975,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 _iter885; - for (_iter885 = this->part_vals.begin(); _iter885 != this->part_vals.end(); ++_iter885) + std::vector<std::string> ::const_iterator _iter886; + for (_iter886 = this->part_vals.begin(); _iter886 != this->part_vals.end(); ++_iter886) { - xfer += oprot->writeString((*_iter885)); + xfer += oprot->writeString((*_iter886)); } xfer += oprot->writeListEnd(); } @@ -10019,10 +10019,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 _iter886; - for (_iter886 = (*(this->part_vals)).begin(); _iter886 != (*(this->part_vals)).end(); ++_iter886) + std::vector<std::string> ::const_iterator _iter887; + for (_iter887 = (*(this->part_vals)).begin(); _iter887 != (*(this->part_vals)).end(); ++_iter887) { - xfer += oprot->writeString((*_iter886)); + xfer += oprot->writeString((*_iter887)); } xfer += oprot->writeListEnd(); } @@ -11023,14 +11023,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + 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) { - xfer += iprot->readString(this->part_vals[_i891]); + xfer += iprot->readString(this->part_vals[_i892]); } xfer += iprot->readListEnd(); } @@ -11067,10 +11067,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 _iter892; - for (_iter892 = this->part_vals.begin(); _iter892 != this->part_vals.end(); ++_iter892) + std::vector<std::string> ::const_iterator _iter893; + for (_iter893 = this->part_vals.begin(); _iter893 != this->part_vals.end(); ++_iter893) { - xfer += oprot->writeString((*_iter892)); + xfer += oprot->writeString((*_iter893)); } xfer += oprot->writeListEnd(); } @@ -11103,10 +11103,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 _iter893; - for (_iter893 = (*(this->part_vals)).begin(); _iter893 != (*(this->part_vals)).end(); ++_iter893) + std::vector<std::string> ::const_iterator _iter894; + for (_iter894 = (*(this->part_vals)).begin(); _iter894 != (*(this->part_vals)).end(); ++_iter894) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter894)); } xfer += oprot->writeListEnd(); } @@ -11293,17 +11293,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - 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) + 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) { - std::string _key899; - xfer += iprot->readString(_key899); - std::string& _val900 = this->partitionSpecs[_key899]; - xfer += iprot->readString(_val900); + std::string _key900; + xfer += iprot->readString(_key900); + std::string& _val901 = this->partitionSpecs[_key900]; + xfer += iprot->readString(_val901); } xfer += iprot->readMapEnd(); } @@ -11364,11 +11364,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 _iter901; - for (_iter901 = this->partitionSpecs.begin(); _iter901 != this->partitionSpecs.end(); ++_iter901) + std::map<std::string, std::string> ::const_iterator _iter902; + for (_iter902 = this->partitionSpecs.begin(); _iter902 != this->partitionSpecs.end(); ++_iter902) { - xfer += oprot->writeString(_iter901->first); - xfer += oprot->writeString(_iter901->second); + xfer += oprot->writeString(_iter902->first); + xfer += oprot->writeString(_iter902->second); } xfer += oprot->writeMapEnd(); } @@ -11409,11 +11409,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 _iter902; - for (_iter902 = (*(this->partitionSpecs)).begin(); _iter902 != (*(this->partitionSpecs)).end(); ++_iter902) + std::map<std::string, std::string> ::const_iterator _iter903; + for (_iter903 = (*(this->partitionSpecs)).begin(); _iter903 != (*(this->partitionSpecs)).end(); ++_iter903) { - xfer += oprot->writeString(_iter902->first); - xfer += oprot->writeString(_iter902->second); + xfer += oprot->writeString(_iter903->first); + xfer += oprot->writeString(_iter903->second); } xfer += oprot->writeMapEnd(); } @@ -11672,14 +11672,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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i907]); + xfer += iprot->readString(this->part_vals[_i908]); } xfer += iprot->readListEnd(); } @@ -11700,14 +11700,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 _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) + 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) { - xfer += iprot->readString(this->group_names[_i912]); + xfer += iprot->readString(this->group_names[_i913]); } xfer += iprot->readListEnd(); } @@ -11744,10 +11744,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 _iter913; - for (_iter913 = this->part_vals.begin(); _iter913 != this->part_vals.end(); ++_iter913) + std::vector<std::string> ::const_iterator _iter914; + for (_iter914 = this->part_vals.begin(); _iter914 != this->part_vals.end(); ++_iter914) { - xfer += oprot->writeString((*_iter913)); + xfer += oprot->writeString((*_iter914)); } xfer += oprot->writeListEnd(); } @@ -11760,10 +11760,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 _iter914; - for (_iter914 = this->group_names.begin(); _iter914 != this->group_names.end(); ++_iter914) + std::vector<std::string> ::const_iterator _iter915; + for (_iter915 = this->group_names.begin(); _iter915 != this->group_names.end(); ++_iter915) { - xfer += oprot->writeString((*_iter914)); + xfer += oprot->writeString((*_iter915)); } xfer += oprot->writeListEnd(); } @@ -11796,10 +11796,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 _iter915; - for (_iter915 = (*(this->part_vals)).begin(); _iter915 != (*(this->part_vals)).end(); ++_iter915) + std::vector<std::string> ::const_iterator _iter916; + for (_iter916 = (*(this->part_vals)).begin(); _iter916 != (*(this->part_vals)).end(); ++_iter916) { - xfer += oprot->writeString((*_iter915)); + xfer += oprot->writeString((*_iter916)); } xfer += oprot->writeListEnd(); } @@ -11812,10 +11812,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 _iter916; - for (_iter916 = (*(this->group_names)).begin(); _iter916 != (*(this->group_names)).end(); ++_iter916) + std::vector<std::string> ::const_iterator _iter917; + for (_iter917 = (*(this->group_names)).begin(); _iter917 != (*(this->group_names)).end(); ++_iter917) { - xfer += oprot->writeString((*_iter916)); + xfer += oprot->writeString((*_iter917)); } xfer += oprot->writeListEnd(); } @@ -12372,14 +12372,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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[_i921].read(iprot); + xfer += this->success[_i922].read(iprot); } xfer += iprot->readListEnd(); } @@ -12426,10 +12426,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 _iter922; - for (_iter922 = this->success.begin(); _iter922 != this->success.end(); ++_iter922) + std::vector<Partition> ::const_iterator _iter923; + for (_iter923 = this->success.begin(); _iter923 != this->success.end(); ++_iter923) { - xfer += (*_iter922).write(oprot); + xfer += (*_iter923).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12477,14 +12477,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size923; - ::apache::thrift::protocol::TType _etype926; - xfer += iprot->readListBegin(_etype926, _size923); - (*(this->success)).resize(_size923); - uint32_t _i927; - for (_i927 = 0; _i927 < _size923; ++_i927) + uint32_t _size924; + ::apache::thrift::protocol::TType _etype927; + xfer += iprot->readListBegin(_etype927, _size924); + (*(this->success)).resize(_size924); + uint32_t _i928; + for (_i928 = 0; _i928 < _size924; ++_i928) { - xfer += (*(this->success))[_i927].read(iprot); + xfer += (*(this->success))[_i928].read(iprot); } xfer += iprot->readListEnd(); } @@ -12582,14 +12582,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 _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) + 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) { - xfer += iprot->readString(this->group_names[_i932]); + xfer += iprot->readString(this->group_names[_i933]); } xfer += iprot->readListEnd(); } @@ -12634,10 +12634,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 _iter933; - for (_iter933 = this->group_names.begin(); _iter933 != this->group_names.end(); ++_iter933) + std::vector<std::string> ::const_iterator _iter934; + for (_iter934 = this->group_names.begin(); _iter934 != this->group_names.end(); ++_iter934) { - xfer += oprot->writeString((*_iter933)); + xfer += oprot->writeString((*_iter934)); } xfer += oprot->writeListEnd(); } @@ -12678,10 +12678,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 _iter934; - for (_iter934 = (*(this->group_names)).begin(); _iter934 != (*(this->group_names)).end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter935; + for (_iter935 = (*(this->group_names)).begin(); _iter935 != (*(this->group_names)).end(); ++_iter935) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -12722,14 +12722,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i939].read(iprot); + xfer += this->success[_i940].read(iprot); } xfer += iprot->readListEnd(); } @@ -12776,10 +12776,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 _iter940; - for (_iter940 = this->success.begin(); _iter940 != this->success.end(); ++_iter940) + std::vector<Partition> ::const_iterator _iter941; + for (_iter941 = this->success.begin(); _iter941 != this->success.end(); ++_iter941) { - xfer += (*_iter940).write(oprot); + xfer += (*_iter941).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12827,14 +12827,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - (*(this->success)).resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size942; + ::apache::thrift::protocol::TType _etype945; + xfer += iprot->readListBegin(_etype945, _size942); + (*(this->success)).resize(_size942); + uint32_t _i946; + for (_i946 = 0; _i946 < _size942; ++_i946) { - xfer += (*(this->success))[_i945].read(iprot); + xfer += (*(this->success))[_i946].read(iprot); } xfer += iprot->readListEnd(); } @@ -13012,14 +13012,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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[_i950].read(iprot); + xfer += this->success[_i951].read(iprot); } xfer += iprot->readListEnd(); } @@ -13066,10 +13066,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 _iter951; - for (_iter951 = this->success.begin(); _iter951 != this->success.end(); ++_iter951) + std::vector<PartitionSpec> ::const_iterator _iter952; + for (_iter952 = this->success.begin(); _iter952 != this->success.end(); ++_iter952) { - xfer += (*_iter951).write(oprot); + xfer += (*_iter952).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13117,14 +13117,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += (*(this->success))[_i956].read(iprot); + xfer += (*(this->success))[_i957].read(iprot); } xfer += iprot->readListEnd(); } @@ -13302,14 +13302,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i961]); + xfer += iprot->readString(this->success[_i962]); } xfer += iprot->readListEnd(); } @@ -13348,10 +13348,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 _iter962; - for (_iter962 = this->success.begin(); _iter962 != this->success.end(); ++_iter962) + std::vector<std::string> ::const_iterator _iter963; + for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter963)); } xfer += oprot->writeListEnd(); } @@ -13395,14 +13395,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += iprot->readString((*(this->success))[_i967]); + xfer += iprot->readString((*(this->success))[_i968]); } xfer += iprot->readListEnd(); } @@ -13476,14 +13476,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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i972]); + xfer += iprot->readString(this->part_vals[_i973]); } xfer += iprot->readListEnd(); } @@ -13528,10 +13528,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 _iter973; - for (_iter973 = this->part_vals.begin(); _iter973 != this->part_vals.end(); ++_iter973) + std::vector<std::string> ::const_iterator _iter974; + for (_iter974 = this->part_vals.begin(); _iter974 != this->part_vals.end(); ++_iter974) { - xfer += oprot->writeString((*_iter973)); + xfer += oprot->writeString((*_iter974)); } xfer += oprot->writeListEnd(); } @@ -13568,10 +13568,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 _iter974; - for (_iter974 = (*(this->part_vals)).begin(); _iter974 != (*(this->part_vals)).end(); ++_iter974) + std::vector<std::string> ::const_iterator _iter975; + for (_iter975 = (*(this->part_vals)).begin(); _iter975 != (*(this->part_vals)).end(); ++_iter975) { - xfer += oprot->writeString((*_iter974)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -13616,14 +13616,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i979].read(iprot); + xfer += this->success[_i980].read(iprot); } xfer += iprot->readListEnd(); } @@ -13670,10 +13670,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 _iter980; - for (_iter980 = this->success.begin(); _iter980 != this->success.end(); ++_iter980) + std::vector<Partition> ::const_iterator _iter981; + for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) { - xfer += (*_iter980).write(oprot); + xfer += (*_iter981).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13721,14 +13721,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += (*(this->success))[_i985].read(iprot); + xfer += (*(this->success))[_i986].read(iprot); } xfer += iprot->readListEnd(); } @@ -13810,14 +13810,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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i990]); + xfer += iprot->readString(this->part_vals[_i991]); } xfer += iprot->readListEnd(); } @@ -13846,14 +13846,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 _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) + 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) { - xfer += iprot->readString(this->group_names[_i995]); + xfer += iprot->readString(this->group_names[_i996]); } xfer += iprot->readListEnd(); } @@ -13890,10 +13890,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 _iter996; - for (_iter996 = this->part_vals.begin(); _iter996 != this->part_vals.end(); ++_iter996) + std::vector<std::string> ::const_iterator _iter997; + for (_iter997 = this->part_vals.begin(); _iter997 != this->part_vals.end(); ++_iter997) { - xfer += oprot->writeString((*_iter996)); + xfer += oprot->writeString((*_iter997)); } xfer += oprot->writeListEnd(); } @@ -13910,10 +13910,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 _iter997; - for (_iter997 = this->group_names.begin(); _iter997 != this->group_names.end(); ++_iter997) + std::vector<std::string> ::const_iterator _iter998; + for (_iter998 = this->group_names.begin(); _iter998 != this->group_names.end(); ++_iter998) { - xfer += oprot->writeString((*_iter997)); + xfer += oprot->writeString((*_iter998)); } xfer += oprot->writeListEnd(); } @@ -13946,10 +13946,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 _iter998; - for (_iter998 = (*(this->part_vals)).begin(); _iter998 != (*(this->part_vals)).end(); ++_iter998) + std::vector<std::string> ::const_iterator _iter999; + for (_iter999 = (*(this->part_vals)).begin(); _iter999 != (*(this->part_vals)).end(); ++_iter999) { - xfer += oprot->writeString((*_iter998)); + xfer += oprot->writeString((*_iter999)); } xfer += oprot->writeListEnd(); } @@ -13966,10 +13966,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 _iter999; - for (_iter999 = (*(this->group_names)).begin(); _iter999 != (*(this->group_names)).end(); ++_iter999) + std::vector<std::string> ::const_iterator _iter1000; + for (_iter1000 = (*(this->group_names)).begin(); _iter1000 != (*(this->group_names)).end(); ++_iter1000) { - xfer += oprot->writeString((*_iter999)); + xfer += oprot->writeString((*_iter1000)); } xfer += oprot->writeListEnd(); } @@ -14010,14 +14010,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i1004].read(iprot); + xfer += this->success[_i1005].read(iprot); } xfer += iprot->readListEnd(); } @@ -14064,10 +14064,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 _iter1005; - for (_iter1005 = this->success.begin(); _iter1005 != this->success.end(); ++_iter1005) + std::vector<Partition> ::const_iterator _iter1006; + for (_iter1006 = this->success.begin(); _iter1006 != this->success.end(); ++_iter1006) { - xfer += (*_iter1005).write(oprot); + xfer += (*_iter1006).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14115,14 +14115,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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) { - xfer += (*(this->success))[_i1010].read(iprot); + xfer += (*(this->success))[_i1011].read(iprot); } xfer += iprot->readListEnd(); } @@ -14204,14 +14204,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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1015]); + xfer += iprot->readString(this->part_vals[_i1016]); } xfer += iprot->readListEnd(); } @@ -14256,10 +14256,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 _iter1016; - for (_iter1016 = this->part_vals.begin(); _iter1016 != this->part_vals.end(); ++_iter1016) + std::vector<std::string> ::const_iterator _iter1017; + for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017) { - xfer += oprot->writeString((*_iter1016)); + xfer +
<TRUNCATED>