http://git-wip-us.apache.org/repos/asf/hive/blob/b678ed85/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 6a80db7..0443f80 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 _size716; + ::apache::thrift::protocol::TType _etype719; + xfer += iprot->readListBegin(_etype719, _size716); + this->success.resize(_size716); + uint32_t _i720; + for (_i720 = 0; _i720 < _size716; ++_i720) { - xfer += iprot->readString(this->success[_i718]); + xfer += iprot->readString(this->success[_i720]); } 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 _iter721; + for (_iter721 = this->success.begin(); _iter721 != this->success.end(); ++_iter721) { - xfer += oprot->writeString((*_iter719)); + xfer += oprot->writeString((*_iter721)); } 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 _size722; + ::apache::thrift::protocol::TType _etype725; + xfer += iprot->readListBegin(_etype725, _size722); + (*(this->success)).resize(_size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - xfer += iprot->readString((*(this->success))[_i724]); + xfer += iprot->readString((*(this->success))[_i726]); } 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 _size727; + ::apache::thrift::protocol::TType _etype730; + xfer += iprot->readListBegin(_etype730, _size727); + this->success.resize(_size727); + uint32_t _i731; + for (_i731 = 0; _i731 < _size727; ++_i731) { - xfer += iprot->readString(this->success[_i729]); + xfer += iprot->readString(this->success[_i731]); } 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 _iter732; + for (_iter732 = this->success.begin(); _iter732 != this->success.end(); ++_iter732) { - xfer += oprot->writeString((*_iter730)); + xfer += oprot->writeString((*_iter732)); } 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 _size733; + ::apache::thrift::protocol::TType _etype736; + xfer += iprot->readListBegin(_etype736, _size733); + (*(this->success)).resize(_size733); + uint32_t _i737; + for (_i737 = 0; _i737 < _size733; ++_i737) { - xfer += iprot->readString((*(this->success))[_i735]); + xfer += iprot->readString((*(this->success))[_i737]); } 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 _size738; + ::apache::thrift::protocol::TType _ktype739; + ::apache::thrift::protocol::TType _vtype740; + xfer += iprot->readMapBegin(_ktype739, _vtype740, _size738); + uint32_t _i742; + for (_i742 = 0; _i742 < _size738; ++_i742) { - std::string _key741; - xfer += iprot->readString(_key741); - Type& _val742 = this->success[_key741]; - xfer += _val742.read(iprot); + std::string _key743; + xfer += iprot->readString(_key743); + Type& _val744 = this->success[_key743]; + xfer += _val744.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 _iter745; + for (_iter745 = this->success.begin(); _iter745 != this->success.end(); ++_iter745) { - xfer += oprot->writeString(_iter743->first); - xfer += _iter743->second.write(oprot); + xfer += oprot->writeString(_iter745->first); + xfer += _iter745->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 _size746; + ::apache::thrift::protocol::TType _ktype747; + ::apache::thrift::protocol::TType _vtype748; + xfer += iprot->readMapBegin(_ktype747, _vtype748, _size746); + uint32_t _i750; + for (_i750 = 0; _i750 < _size746; ++_i750) { - std::string _key749; - xfer += iprot->readString(_key749); - Type& _val750 = (*(this->success))[_key749]; - xfer += _val750.read(iprot); + std::string _key751; + xfer += iprot->readString(_key751); + Type& _val752 = (*(this->success))[_key751]; + xfer += _val752.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 _size753; + ::apache::thrift::protocol::TType _etype756; + xfer += iprot->readListBegin(_etype756, _size753); + this->success.resize(_size753); + uint32_t _i757; + for (_i757 = 0; _i757 < _size753; ++_i757) { - xfer += this->success[_i755].read(iprot); + xfer += this->success[_i757].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 _iter758; + for (_iter758 = this->success.begin(); _iter758 != this->success.end(); ++_iter758) { - xfer += (*_iter756).write(oprot); + xfer += (*_iter758).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 _size759; + ::apache::thrift::protocol::TType _etype762; + xfer += iprot->readListBegin(_etype762, _size759); + (*(this->success)).resize(_size759); + uint32_t _i763; + for (_i763 = 0; _i763 < _size759; ++_i763) { - xfer += (*(this->success))[_i761].read(iprot); + xfer += (*(this->success))[_i763].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 _size764; + ::apache::thrift::protocol::TType _etype767; + xfer += iprot->readListBegin(_etype767, _size764); + this->success.resize(_size764); + uint32_t _i768; + for (_i768 = 0; _i768 < _size764; ++_i768) { - xfer += this->success[_i766].read(iprot); + xfer += this->success[_i768].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 _iter769; + for (_iter769 = this->success.begin(); _iter769 != this->success.end(); ++_iter769) { - xfer += (*_iter767).write(oprot); + xfer += (*_iter769).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 _size770; + ::apache::thrift::protocol::TType _etype773; + xfer += iprot->readListBegin(_etype773, _size770); + (*(this->success)).resize(_size770); + uint32_t _i774; + for (_i774 = 0; _i774 < _size770; ++_i774) { - xfer += (*(this->success))[_i772].read(iprot); + xfer += (*(this->success))[_i774].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 _size775; + ::apache::thrift::protocol::TType _etype778; + xfer += iprot->readListBegin(_etype778, _size775); + this->success.resize(_size775); + uint32_t _i779; + for (_i779 = 0; _i779 < _size775; ++_i779) { - xfer += this->success[_i777].read(iprot); + xfer += this->success[_i779].read(iprot); } xfer += iprot->readListEnd(); } @@ -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 _iter780; + for (_iter780 = this->success.begin(); _iter780 != this->success.end(); ++_iter780) { - xfer += (*_iter778).write(oprot); + xfer += (*_iter780).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 _size781; + ::apache::thrift::protocol::TType _etype784; + xfer += iprot->readListBegin(_etype784, _size781); + (*(this->success)).resize(_size781); + uint32_t _i785; + for (_i785 = 0; _i785 < _size781; ++_i785) { - xfer += (*(this->success))[_i783].read(iprot); + xfer += (*(this->success))[_i785].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 _size786; + ::apache::thrift::protocol::TType _etype789; + xfer += iprot->readListBegin(_etype789, _size786); + this->success.resize(_size786); + uint32_t _i790; + for (_i790 = 0; _i790 < _size786; ++_i790) { - xfer += this->success[_i788].read(iprot); + xfer += this->success[_i790].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 _iter791; + for (_iter791 = this->success.begin(); _iter791 != this->success.end(); ++_iter791) { - xfer += (*_iter789).write(oprot); + xfer += (*_iter791).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 _size792; + ::apache::thrift::protocol::TType _etype795; + xfer += iprot->readListBegin(_etype795, _size792); + (*(this->success)).resize(_size792); + uint32_t _i796; + for (_i796 = 0; _i796 < _size792; ++_i796) { - xfer += (*(this->success))[_i794].read(iprot); + xfer += (*(this->success))[_i796].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 _size797; + ::apache::thrift::protocol::TType _etype800; + xfer += iprot->readListBegin(_etype800, _size797); + this->success.resize(_size797); + uint32_t _i801; + for (_i801 = 0; _i801 < _size797; ++_i801) { - xfer += iprot->readString(this->success[_i799]); + xfer += iprot->readString(this->success[_i801]); } 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 _iter802; + for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) { - xfer += oprot->writeString((*_iter800)); + xfer += oprot->writeString((*_iter802)); } xfer += oprot->writeListEnd(); } @@ -5193,14 +5193,313 @@ 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 _size803; + ::apache::thrift::protocol::TType _etype806; + xfer += iprot->readListBegin(_etype806, _size803); + (*(this->success)).resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += iprot->readString((*(this->success))[_i805]); + xfer += iprot->readString((*(this->success))[_i807]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_args::~ThriftHiveMetastore_get_table_meta_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_patterns); + this->__isset.db_patterns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_patterns); + this->__isset.tbl_patterns = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->tbl_types.clear(); + uint32_t _size808; + ::apache::thrift::protocol::TType _etype811; + xfer += iprot->readListBegin(_etype811, _size808); + this->tbl_types.resize(_size808); + uint32_t _i812; + for (_i812 = 0; _i812 < _size808; ++_i812) + { + xfer += iprot->readString(this->tbl_types[_i812]); + } + xfer += iprot->readListEnd(); + } + this->__isset.tbl_types = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_args"); + + xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_patterns); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_patterns); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size())); + std::vector<std::string> ::const_iterator _iter813; + for (_iter813 = this->tbl_types.begin(); _iter813 != this->tbl_types.end(); ++_iter813) + { + xfer += oprot->writeString((*_iter813)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_pargs::~ThriftHiveMetastore_get_table_meta_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_pargs"); + + xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_patterns))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_patterns))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size())); + std::vector<std::string> ::const_iterator _iter814; + for (_iter814 = (*(this->tbl_types)).begin(); _iter814 != (*(this->tbl_types)).end(); ++_iter814) + { + xfer += oprot->writeString((*_iter814)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_result::~ThriftHiveMetastore_get_table_meta_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->success.clear(); + uint32_t _size815; + ::apache::thrift::protocol::TType _etype818; + xfer += iprot->readListBegin(_etype818, _size815); + this->success.resize(_size815); + uint32_t _i819; + for (_i819 = 0; _i819 < _size815; ++_i819) + { + xfer += this->success[_i819].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); + std::vector<TableMeta> ::const_iterator _iter820; + for (_iter820 = this->success.begin(); _iter820 != this->success.end(); ++_iter820) + { + xfer += (*_iter820).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_table_meta_presult::~ThriftHiveMetastore_get_table_meta_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size821; + ::apache::thrift::protocol::TType _etype824; + xfer += iprot->readListBegin(_etype824, _size821); + (*(this->success)).resize(_size821); + uint32_t _i825; + for (_i825 = 0; _i825 < _size821; ++_i825) + { + xfer += (*(this->success))[_i825].read(iprot); } xfer += iprot->readListEnd(); } @@ -5338,14 +5637,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 _size826; + ::apache::thrift::protocol::TType _etype829; + xfer += iprot->readListBegin(_etype829, _size826); + this->success.resize(_size826); + uint32_t _i830; + for (_i830 = 0; _i830 < _size826; ++_i830) { - xfer += iprot->readString(this->success[_i810]); + xfer += iprot->readString(this->success[_i830]); } xfer += iprot->readListEnd(); } @@ -5384,10 +5683,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 _iter831; + for (_iter831 = this->success.begin(); _iter831 != this->success.end(); ++_iter831) { - xfer += oprot->writeString((*_iter811)); + xfer += oprot->writeString((*_iter831)); } xfer += oprot->writeListEnd(); } @@ -5432,14 +5731,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 _size832; + ::apache::thrift::protocol::TType _etype835; + xfer += iprot->readListBegin(_etype835, _size832); + (*(this->success)).resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += iprot->readString((*(this->success))[_i816]); + xfer += iprot->readString((*(this->success))[_i836]); } xfer += iprot->readListEnd(); } @@ -5749,14 +6048,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 _size837; + ::apache::thrift::protocol::TType _etype840; + xfer += iprot->readListBegin(_etype840, _size837); + this->tbl_names.resize(_size837); + uint32_t _i841; + for (_i841 = 0; _i841 < _size837; ++_i841) { - xfer += iprot->readString(this->tbl_names[_i821]); + xfer += iprot->readString(this->tbl_names[_i841]); } xfer += iprot->readListEnd(); } @@ -5789,10 +6088,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 _iter842; + for (_iter842 = this->tbl_names.begin(); _iter842 != this->tbl_names.end(); ++_iter842) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter842)); } xfer += oprot->writeListEnd(); } @@ -5820,10 +6119,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 _iter843; + for (_iter843 = (*(this->tbl_names)).begin(); _iter843 != (*(this->tbl_names)).end(); ++_iter843) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter843)); } xfer += oprot->writeListEnd(); } @@ -5864,14 +6163,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 _size844; + ::apache::thrift::protocol::TType _etype847; + xfer += iprot->readListBegin(_etype847, _size844); + this->success.resize(_size844); + uint32_t _i848; + for (_i848 = 0; _i848 < _size844; ++_i848) { - xfer += this->success[_i828].read(iprot); + xfer += this->success[_i848].read(iprot); } xfer += iprot->readListEnd(); } @@ -5926,10 +6225,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 _iter849; + for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) { - xfer += (*_iter829).write(oprot); + xfer += (*_iter849).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +6281,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 _size850; + ::apache::thrift::protocol::TType _etype853; + xfer += iprot->readListBegin(_etype853, _size850); + (*(this->success)).resize(_size850); + uint32_t _i854; + for (_i854 = 0; _i854 < _size850; ++_i854) { - xfer += (*(this->success))[_i834].read(iprot); + xfer += (*(this->success))[_i854].read(iprot); } xfer += iprot->readListEnd(); } @@ -6175,14 +6474,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 _size855; + ::apache::thrift::protocol::TType _etype858; + xfer += iprot->readListBegin(_etype858, _size855); + this->success.resize(_size855); + uint32_t _i859; + for (_i859 = 0; _i859 < _size855; ++_i859) { - xfer += iprot->readString(this->success[_i839]); + xfer += iprot->readString(this->success[_i859]); } xfer += iprot->readListEnd(); } @@ -6237,10 +6536,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 _iter860; + for (_iter860 = this->success.begin(); _iter860 != this->success.end(); ++_iter860) { - xfer += oprot->writeString((*_iter840)); + xfer += oprot->writeString((*_iter860)); } xfer += oprot->writeListEnd(); } @@ -6293,14 +6592,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 _size861; + ::apache::thrift::protocol::TType _etype864; + xfer += iprot->readListBegin(_etype864, _size861); + (*(this->success)).resize(_size861); + uint32_t _i865; + for (_i865 = 0; _i865 < _size861; ++_i865) { - xfer += iprot->readString((*(this->success))[_i845]); + xfer += iprot->readString((*(this->success))[_i865]); } xfer += iprot->readListEnd(); } @@ -7634,14 +7933,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 _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + this->new_parts.resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += this->new_parts[_i850].read(iprot); + xfer += this->new_parts[_i870].read(iprot); } xfer += iprot->readListEnd(); } @@ -7670,10 +7969,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 _iter871; + for (_iter871 = this->new_parts.begin(); _iter871 != this->new_parts.end(); ++_iter871) { - xfer += (*_iter851).write(oprot); + xfer += (*_iter871).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7697,10 +7996,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 _iter872; + for (_iter872 = (*(this->new_parts)).begin(); _iter872 != (*(this->new_parts)).end(); ++_iter872) { - xfer += (*_iter852).write(oprot); + xfer += (*_iter872).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7909,14 +8208,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 _size873; + ::apache::thrift::protocol::TType _etype876; + xfer += iprot->readListBegin(_etype876, _size873); + this->new_parts.resize(_size873); + uint32_t _i877; + for (_i877 = 0; _i877 < _size873; ++_i877) { - xfer += this->new_parts[_i857].read(iprot); + xfer += this->new_parts[_i877].read(iprot); } xfer += iprot->readListEnd(); } @@ -7945,10 +8244,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 _iter878; + for (_iter878 = this->new_parts.begin(); _iter878 != this->new_parts.end(); ++_iter878) { - xfer += (*_iter858).write(oprot); + xfer += (*_iter878).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7972,10 +8271,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 _iter879; + for (_iter879 = (*(this->new_parts)).begin(); _iter879 != (*(this->new_parts)).end(); ++_iter879) { - xfer += (*_iter859).write(oprot); + xfer += (*_iter879).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8200,14 +8499,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 _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[_i864]); + xfer += iprot->readString(this->part_vals[_i884]); } xfer += iprot->readListEnd(); } @@ -8244,10 +8543,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 _iter885; + for (_iter885 = this->part_vals.begin(); _iter885 != this->part_vals.end(); ++_iter885) { - xfer += oprot->writeString((*_iter865)); + xfer += oprot->writeString((*_iter885)); } xfer += oprot->writeListEnd(); } @@ -8279,10 +8578,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 _iter886; + for (_iter886 = (*(this->part_vals)).begin(); _iter886 != (*(this->part_vals)).end(); ++_iter886) { - xfer += oprot->writeString((*_iter866)); + xfer += oprot->writeString((*_iter886)); } xfer += oprot->writeListEnd(); } @@ -8754,14 +9053,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 _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[_i871]); + xfer += iprot->readString(this->part_vals[_i891]); } xfer += iprot->readListEnd(); } @@ -8806,10 +9105,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 _iter892; + for (_iter892 = this->part_vals.begin(); _iter892 != this->part_vals.end(); ++_iter892) { - xfer += oprot->writeString((*_iter872)); + xfer += oprot->writeString((*_iter892)); } xfer += oprot->writeListEnd(); } @@ -8845,10 +9144,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 _iter893; + for (_iter893 = (*(this->part_vals)).begin(); _iter893 != (*(this->part_vals)).end(); ++_iter893) { - xfer += oprot->writeString((*_iter873)); + xfer += oprot->writeString((*_iter893)); } xfer += oprot->writeListEnd(); } @@ -9651,14 +9950,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 _size894; + ::apache::thrift::protocol::TType _etype897; + xfer += iprot->readListBegin(_etype897, _size894); + this->part_vals.resize(_size894); + uint32_t _i898; + for (_i898 = 0; _i898 < _size894; ++_i898) { - xfer += iprot->readString(this->part_vals[_i878]); + xfer += iprot->readString(this->part_vals[_i898]); } xfer += iprot->readListEnd(); } @@ -9703,10 +10002,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 _iter899; + for (_iter899 = this->part_vals.begin(); _iter899 != this->part_vals.end(); ++_iter899) { - xfer += oprot->writeString((*_iter879)); + xfer += oprot->writeString((*_iter899)); } xfer += oprot->writeListEnd(); } @@ -9742,10 +10041,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 _iter900; + for (_iter900 = (*(this->part_vals)).begin(); _iter900 != (*(this->part_vals)).end(); ++_iter900) { - xfer += oprot->writeString((*_iter880)); + xfer += oprot->writeString((*_iter900)); } xfer += oprot->writeListEnd(); } @@ -9954,14 +10253,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 _size901; + ::apache::thrift::protocol::TType _etype904; + xfer += iprot->readListBegin(_etype904, _size901); + this->part_vals.resize(_size901); + uint32_t _i905; + for (_i905 = 0; _i905 < _size901; ++_i905) { - xfer += iprot->readString(this->part_vals[_i885]); + xfer += iprot->readString(this->part_vals[_i905]); } xfer += iprot->readListEnd(); } @@ -10014,10 +10313,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 _iter906; + for (_iter906 = this->part_vals.begin(); _iter906 != this->part_vals.end(); ++_iter906) { - xfer += oprot->writeString((*_iter886)); + xfer += oprot->writeString((*_iter906)); } xfer += oprot->writeListEnd(); } @@ -10057,10 +10356,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 _iter907; + for (_iter907 = (*(this->part_vals)).begin(); _iter907 != (*(this->part_vals)).end(); ++_iter907) { - xfer += oprot->writeString((*_iter887)); + xfer += oprot->writeString((*_iter907)); } xfer += oprot->writeListEnd(); } @@ -11066,14 +11365,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 _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + this->part_vals.resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString(this->part_vals[_i892]); + xfer += iprot->readString(this->part_vals[_i912]); } xfer += iprot->readListEnd(); } @@ -11110,10 +11409,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 _iter913; + for (_iter913 = this->part_vals.begin(); _iter913 != this->part_vals.end(); ++_iter913) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -11145,10 +11444,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 _iter914; + for (_iter914 = (*(this->part_vals)).begin(); _iter914 != (*(this->part_vals)).end(); ++_iter914) { - xfer += oprot->writeString((*_iter894)); + xfer += oprot->writeString((*_iter914)); } xfer += oprot->writeListEnd(); } @@ -11337,17 +11636,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 _size915; + ::apache::thrift::protocol::TType _ktype916; + ::apache::thrift::protocol::TType _vtype917; + xfer += iprot->readMapBegin(_ktype916, _vtype917, _size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - std::string _key900; - xfer += iprot->readString(_key900); - std::string& _val901 = this->partitionSpecs[_key900]; - xfer += iprot->readString(_val901); + std::string _key920; + xfer += iprot->readString(_key920); + std::string& _val921 = this->partitionSpecs[_key920]; + xfer += iprot->readString(_val921); } xfer += iprot->readMapEnd(); } @@ -11408,11 +11707,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 _iter922; + for (_iter922 = this->partitionSpecs.begin(); _iter922 != this->partitionSpecs.end(); ++_iter922) { - xfer += oprot->writeString(_iter902->first); - xfer += oprot->writeString(_iter902->second); + xfer += oprot->writeString(_iter922->first); + xfer += oprot->writeString(_iter922->second); } xfer += oprot->writeMapEnd(); } @@ -11452,11 +11751,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 _iter923; + for (_iter923 = (*(this->partitionSpecs)).begin(); _iter923 != (*(this->partitionSpecs)).end(); ++_iter923) { - xfer += oprot->writeString(_iter903->first); - xfer += oprot->writeString(_iter903->second); + xfer += oprot->writeString(_iter923->first); + xfer += oprot->writeString(_iter923->second); } xfer += oprot->writeMapEnd(); } @@ -11701,17 +12000,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size904; - ::apache::thrift::protocol::TType _ktype905; - ::apache::thrift::protocol::TType _vtype906; - xfer += iprot->readMapBegin(_ktype905, _vtype906, _size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size924; + ::apache::thrift::protocol::TType _ktype925; + ::apache::thrift::protocol::TType _vtype926; + xfer += iprot->readMapBegin(_ktype925, _vtype926, _size924); + uint32_t _i928; + for (_i928 = 0; _i928 < _size924; ++_i928) { - std::string _key909; - xfer += iprot->readString(_key909); - std::string& _val910 = this->partitionSpecs[_key909]; - xfer += iprot->readString(_val910); + std::string _key929; + xfer += iprot->readString(_key929); + std::string& _val930 = this->partitionSpecs[_key929]; + xfer += iprot->readString(_val930); } xfer += iprot->readMapEnd(); } @@ -11772,11 +12071,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter911; - for (_iter911 = this->partitionSpecs.begin(); _iter911 != this->partitionSpecs.end(); ++_iter911) + std::map<std::string, std::string> ::const_iterator _iter931; + for (_iter931 = this->partitionSpecs.begin(); _iter931 != this->partitionSpecs.end(); ++_iter931) { - xfer += oprot->writeString(_iter911->first); - xfer += oprot->writeString(_iter911->second); + xfer += oprot->writeString(_iter931->first); + xfer += oprot->writeString(_iter931->second); } xfer += oprot->writeMapEnd(); } @@ -11816,11 +12115,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter912; - for (_iter912 = (*(this->partitionSpecs)).begin(); _iter912 != (*(this->partitionSpecs)).end(); ++_iter912) + std::map<std::string, std::string> ::const_iterator _iter932; + for (_iter932 = (*(this->partitionSpecs)).begin(); _iter932 != (*(this->partitionSpecs)).end(); ++_iter932) { - xfer += oprot->writeString(_iter912->first); - xfer += oprot->writeString(_iter912->second); + xfer += oprot->writeString(_iter932->first); + xfer += oprot->writeString(_iter932->second); } xfer += oprot->writeMapEnd(); } @@ -11877,14 +12176,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->success.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _size933; + ::apache::thrift::protocol::TType _etype936; + xfer += iprot->readListBegin(_etype936, _size933); + this->success.resize(_size933); + uint32_t _i937; + for (_i937 = 0; _i937 < _size933; ++_i937) { - xfer += this->success[_i917].read(iprot); + xfer += this->success[_i937].read(iprot); } xfer += iprot->readListEnd(); } @@ -11947,10 +12246,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector<Partition> ::const_iterator _iter938; + for (_iter938 = this->success.begin(); _iter938 != this->success.end(); ++_iter938) { - xfer += (*_iter918).write(oprot); + xfer += (*_iter938).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12007,14 +12306,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size939; + ::apache::thrift::protocol::TType _etype942; + xfer += iprot->readListBegin(_etype942, _size939); + (*(this->success)).resize(_size939); + uint32_t _i943; + for (_i943 = 0; _i943 < _size939; ++_i943) { - xfer += (*(this->success))[_i923].read(iprot); + xfer += (*(this->success))[_i943].read(iprot); } xfer += iprot->readListEnd(); } @@ -12113,14 +12412,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 _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - this->part_vals.resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + this->part_vals.resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += iprot->readString(this->part_vals[_i928]); + xfer += iprot->readString(this->part_vals[_i948]); } xfer += iprot->readListEnd(); } @@ -12141,14 +12440,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 _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 _size949; + ::apache::thrift::protocol::TType _etype952; + xfer += iprot->readListBegin(_etype952, _size949); + this->group_names.resize(_size949); + uint32_t _i953; + for (_i953 = 0; _i953 < _size949; ++_i953) { - xfer += iprot->readString(this->group_names[_i933]); + xfer += iprot->readString(this->group_names[_i953]); } xfer += iprot->readListEnd(); } @@ -12185,10 +12484,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 _iter934; - for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter954; + for (_iter954 = this->part_vals.begin(); _iter954 != this->part_vals.end(); ++_iter954) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter954)); } xfer += oprot->writeListEnd(); } @@ -12201,10 +12500,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 _iter935; - for (_iter935 = this->group_names.begin(); _iter935 != this->group_names.end(); ++_iter935) + std::vector<std::string> ::const_iterator _iter955; + for (_iter955 = this->group_names.begin(); _iter955 != this->group_names.end(); ++_iter955) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter955)); } xfer += oprot->writeListEnd(); } @@ -12236,10 +12535,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 _iter936; - for (_iter936 = (*(this->part_vals)).begin(); _iter936 != (*(this->part_vals)).end(); ++_iter936) + std::vector<std::string> ::const_iterator _iter956; + for (_iter956 = (*(this->part_vals)).begin(); _iter956 != (*(this->part_vals)).end(); ++_iter956) { - xfer += oprot->writeString((*_iter936)); + xfer += oprot->writeString((*_iter956)); } xfer += oprot->writeListEnd(); } @@ -12252,10 +12551,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 _iter937; - for (_iter937 = (*(this->group_names)).begin(); _iter937 != (*(this->group_names)).end(); ++_iter937) + std::vector<std::string> ::const_iterator _iter957; + for (_iter957 = (*(this->group_names)).begin(); _iter957 != (*(this->group_names)).end(); ++_iter957) { - xfer += oprot->writeString((*_iter937)); + xfer += oprot->writeString((*_iter957)); } xfer += oprot->writeListEnd(); } @@ -12814,14 +13113,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size938; - ::apache::thrift::protocol::TType _etype941; - xfer += iprot->readListBegin(_etype941, _size938); - this->success.resize(_size938); - uint32_t _i942; - for (_i942 = 0; _i942 < _size938; ++_i942) + 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 += this->success[_i942].read(iprot); + xfer += this->success[_i962].read(iprot); } xfer += iprot->readListEnd(); } @@ -12868,10 +13167,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 _iter943; - for (_iter943 = this->success.begin(); _iter943 != this->success.end(); ++_iter943) + std::vector<Partition> ::const_iterator _iter963; + for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) { - xfer += (*_iter943).write(oprot); + xfer += (*_iter963).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12920,14 +13219,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size944; - ::apache::thrift::protocol::TType _etype947; - xfer += iprot->readListBegin(_etype947, _size944); - (*(this->success)).resize(_size944); - uint32_t _i948; - for (_i948 = 0; _i948 < _size944; ++_i948) + 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 += (*(this->success))[_i948].read(iprot); + xfer += (*(this->success))[_i968].read(iprot); } xfer += iprot->readListEnd(); } @@ -13026,14 +13325,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 _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - this->group_names.resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + uint32_t _size969; + ::apache::thrift::protocol::TType _etype972; + xfer += iprot->readListBegin(_etype972, _size969); + this->group_names.resize(_size969); + uint32_t _i973; + for (_i973 = 0; _i973 < _size969; ++_i973) { - xfer += iprot->readString(this->group_names[_i953]); + xfer += iprot->readString(this->group_names[_i973]); } xfer += iprot->readListEnd(); } @@ -13078,10 +13377,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 _iter954; - for (_iter954 = this->group_names.begin(); _iter954 != this->group_names.end(); ++_iter954) + std::vector<std::string> ::const_iterator _iter974; + for (_iter974 = this->group_names.begin(); _iter974 != this->group_names.end(); ++_iter974) { - xfer += oprot->writeString((*_iter954)); + xfer += oprot->writeString((*_iter974)); } xfer += oprot->writeListEnd(); } @@ -13121,10 +13420,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 _iter955; - for (_iter955 = (*(this->group_names)).begin(); _iter955 != (*(this->group_names)).end(); ++_iter955) + std::vector<std::string> ::const_iterator _iter975; + for (_iter975 = (*(this->group_names)).begin(); _iter975 != (*(this->group_names)).end(); ++_iter975) { - xfer += oprot->writeString((*_iter955)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -13165,14 +13464,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size956; - ::apache::thrift::protocol::TType _etype959; - xfer += iprot->readListBegin(_etype959, _size956); - this->success.resize(_size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + 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[_i960].read(iprot); + xfer += this->success[_i980].read(iprot); } xfer += iprot->readListEnd(); } @@ -13219,10 +13518,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 _iter961; - for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961) + std::vector<Partition> ::const_iterator _iter981; + for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) { - xfer += (*_iter961).write(oprot); + xfer += (*_iter981).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13271,14 +13570,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size962; - ::apache::thrift::protocol::TType _etype965; - xfer += iprot->readListBegin(_etype965, _size962); - (*(this->success)).resize(_size962); - uint32_t _i966; - for (_i966 = 0; _i966 < _size962; ++_i966) + 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))[_i966].read(iprot); + xfer += (*(this->success))[_i986].read(iprot); } xfer += iprot->readListEnd(); } @@ -13456,14 +13755,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size967; - ::apache::thrift::protocol::TType _etype970; - xfer += iprot->readListBegin(_etype970, _size967); - this->success.resize(_size967); - uint32_t _i971; - for (_i971 = 0; _i971 < _size967; ++_i971) + uint32_t _size987; + ::apache::thrift::protocol::TType _etype990; + xfer += iprot->readListBegin(_etype990, _size987); + this->success.resize(_size987); + uint32_t _i991; + for (_i991 = 0; _i991 < _size987; ++_i991) { - xfer += this->success[_i971].read(iprot); + xfer += this->success[_i991].read(iprot); } xfer += iprot->readListEnd(); } @@ -13510,10 +13809,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 _iter972; - for (_iter972 = this->success.begin(); _iter972 != this->success.end(); ++_iter972) + std::vector<PartitionSpec> ::const_iterator _iter992; + for (_iter992 = this->success.begin(); _iter992 != this->success.end(); ++_iter992) { - xfer += (*_iter972).write(oprot); + xfer += (*_iter992).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13562,14 +13861,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size973; - ::apache::thrift::protocol::TType _etype976; - xfer += iprot->readListBegin(_etype976, _size973); - (*(this->success)).resize(_size973); - uint32_t _i977; - for (_i977 = 0; _i977 < _size973; ++_i977) + uint32_t _size993; + ::apache::thrift::protocol::TType _etype996; + xfer += iprot->readListBegin(_etype996, _size993); + (*(this->success)).resize(_size993); + uint32_t _i997; + for (_i997 = 0; _i997 < _size993; ++_i997) { - xfer += (*(this->success))[_i977].read(iprot); + xfer += (*(this->success))[_i997].read(iprot); } xfer += iprot->readListEnd(); } @@ -13747,14 +14046,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size978; - ::apache::thrift::protocol::TType _etype981; - xfer += iprot->readListBegin(_etype981, _size978); - this->success.resize(_size978); - uint32_t _i982; - for (_i982 = 0; _i982 < _size978; ++_i982) + uint32_t _size998; + ::apache::thrift::protocol::TType _etype1001; + xfer += iprot->readListBegin(_etype1001, _size998); + this->success.resize(_size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - xfer += iprot->readString(this->success[_i982]); + xfer += iprot->readString(this->success[_i1002]); } xfer += iprot->readListEnd(); } @@ -13793,10 +14092,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 _iter983; - for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) + std::vector<std::string> ::const_iterator _iter1003; + for (_iter1003 = this->success.begin(); _iter1003 != this->success.end(); ++_iter1003) { - xfer += oprot->writeString((*_iter983)); + xfer += oprot->writeString((*_iter1003)); } xfer += oprot->writeListEnd(); } @@ -13841,14 +14140,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size984; - ::apache::thrift::protocol::TType _etype987; - xfer += iprot->readListBegin(_etype987, _size984); - (*(this->success)).resize(_size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size1004; + ::apache::thrift::protocol::TType _etype1007; + xfer += iprot->readListBegin(_etype1007, _size1004); + (*(this->success)).resize(_size1004); + uint32_t
<TRUNCATED>
