http://git-wip-us.apache.org/repos/asf/hive/blob/10c07d6e/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 2734a1c..29d9ec4 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 _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 _size747; + ::apache::thrift::protocol::TType _etype750; + xfer += iprot->readListBegin(_etype750, _size747); + this->success.resize(_size747); + uint32_t _i751; + for (_i751 = 0; _i751 < _size747; ++_i751) { - xfer += iprot->readString(this->success[_i755]); + xfer += iprot->readString(this->success[_i751]); } 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 _iter756; - for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) + std::vector<std::string> ::const_iterator _iter752; + for (_iter752 = this->success.begin(); _iter752 != this->success.end(); ++_iter752) { - xfer += oprot->writeString((*_iter756)); + xfer += oprot->writeString((*_iter752)); } 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 _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 _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 += iprot->readString((*(this->success))[_i761]); + xfer += iprot->readString((*(this->success))[_i757]); } 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 _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 _size758; + ::apache::thrift::protocol::TType _etype761; + xfer += iprot->readListBegin(_etype761, _size758); + this->success.resize(_size758); + uint32_t _i762; + for (_i762 = 0; _i762 < _size758; ++_i762) { - xfer += iprot->readString(this->success[_i766]); + xfer += iprot->readString(this->success[_i762]); } 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 _iter767; - for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) + std::vector<std::string> ::const_iterator _iter763; + for (_iter763 = this->success.begin(); _iter763 != this->success.end(); ++_iter763) { - xfer += oprot->writeString((*_iter767)); + xfer += oprot->writeString((*_iter763)); } 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 _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 _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 += iprot->readString((*(this->success))[_i772]); + xfer += iprot->readString((*(this->success))[_i768]); } 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 _size773; - ::apache::thrift::protocol::TType _ktype774; - ::apache::thrift::protocol::TType _vtype775; - xfer += iprot->readMapBegin(_ktype774, _vtype775, _size773); - uint32_t _i777; - for (_i777 = 0; _i777 < _size773; ++_i777) + uint32_t _size769; + ::apache::thrift::protocol::TType _ktype770; + ::apache::thrift::protocol::TType _vtype771; + xfer += iprot->readMapBegin(_ktype770, _vtype771, _size769); + uint32_t _i773; + for (_i773 = 0; _i773 < _size769; ++_i773) { - std::string _key778; - xfer += iprot->readString(_key778); - Type& _val779 = this->success[_key778]; - xfer += _val779.read(iprot); + std::string _key774; + xfer += iprot->readString(_key774); + Type& _val775 = this->success[_key774]; + xfer += _val775.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 _iter780; - for (_iter780 = this->success.begin(); _iter780 != this->success.end(); ++_iter780) + std::map<std::string, Type> ::const_iterator _iter776; + for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776) { - xfer += oprot->writeString(_iter780->first); - xfer += _iter780->second.write(oprot); + xfer += oprot->writeString(_iter776->first); + xfer += _iter776->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 _size781; - ::apache::thrift::protocol::TType _ktype782; - ::apache::thrift::protocol::TType _vtype783; - xfer += iprot->readMapBegin(_ktype782, _vtype783, _size781); - uint32_t _i785; - for (_i785 = 0; _i785 < _size781; ++_i785) + uint32_t _size777; + ::apache::thrift::protocol::TType _ktype778; + ::apache::thrift::protocol::TType _vtype779; + xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - std::string _key786; - xfer += iprot->readString(_key786); - Type& _val787 = (*(this->success))[_key786]; - xfer += _val787.read(iprot); + std::string _key782; + xfer += iprot->readString(_key782); + Type& _val783 = (*(this->success))[_key782]; + xfer += _val783.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 _size788; - ::apache::thrift::protocol::TType _etype791; - xfer += iprot->readListBegin(_etype791, _size788); - this->success.resize(_size788); - uint32_t _i792; - for (_i792 = 0; _i792 < _size788; ++_i792) + 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[_i792].read(iprot); + xfer += this->success[_i788].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 _iter793; - for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) + std::vector<FieldSchema> ::const_iterator _iter789; + for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) { - xfer += (*_iter793).write(oprot); + xfer += (*_iter789).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 _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 _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))[_i798].read(iprot); + xfer += (*(this->success))[_i794].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 _size799; - ::apache::thrift::protocol::TType _etype802; - xfer += iprot->readListBegin(_etype802, _size799); - this->success.resize(_size799); - uint32_t _i803; - for (_i803 = 0; _i803 < _size799; ++_i803) + 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 += this->success[_i803].read(iprot); + xfer += this->success[_i799].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 _iter804; - for (_iter804 = this->success.begin(); _iter804 != this->success.end(); ++_iter804) + std::vector<FieldSchema> ::const_iterator _iter800; + for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) { - xfer += (*_iter804).write(oprot); + xfer += (*_iter800).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 _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 _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 += (*(this->success))[_i809].read(iprot); + xfer += (*(this->success))[_i805].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 _size810; - ::apache::thrift::protocol::TType _etype813; - xfer += iprot->readListBegin(_etype813, _size810); - this->success.resize(_size810); - uint32_t _i814; - for (_i814 = 0; _i814 < _size810; ++_i814) + 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 += this->success[_i814].read(iprot); + xfer += this->success[_i810].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 _iter815; - for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) + std::vector<FieldSchema> ::const_iterator _iter811; + for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811) { - xfer += (*_iter815).write(oprot); + xfer += (*_iter811).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 _size816; - ::apache::thrift::protocol::TType _etype819; - xfer += iprot->readListBegin(_etype819, _size816); - (*(this->success)).resize(_size816); - uint32_t _i820; - for (_i820 = 0; _i820 < _size816; ++_i820) + 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 += (*(this->success))[_i820].read(iprot); + xfer += (*(this->success))[_i816].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 _size821; - ::apache::thrift::protocol::TType _etype824; - xfer += iprot->readListBegin(_etype824, _size821); - this->success.resize(_size821); - uint32_t _i825; - for (_i825 = 0; _i825 < _size821; ++_i825) + uint32_t _size817; + ::apache::thrift::protocol::TType _etype820; + xfer += iprot->readListBegin(_etype820, _size817); + this->success.resize(_size817); + uint32_t _i821; + for (_i821 = 0; _i821 < _size817; ++_i821) { - xfer += this->success[_i825].read(iprot); + xfer += this->success[_i821].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 _iter826; - for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) + std::vector<FieldSchema> ::const_iterator _iter822; + for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) { - xfer += (*_iter826).write(oprot); + xfer += (*_iter822).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 _size827; - ::apache::thrift::protocol::TType _etype830; - xfer += iprot->readListBegin(_etype830, _size827); - (*(this->success)).resize(_size827); - uint32_t _i831; - for (_i831 = 0; _i831 < _size827; ++_i831) + uint32_t _size823; + ::apache::thrift::protocol::TType _etype826; + xfer += iprot->readListBegin(_etype826, _size823); + (*(this->success)).resize(_size823); + uint32_t _i827; + for (_i827 = 0; _i827 < _size823; ++_i827) { - xfer += (*(this->success))[_i831].read(iprot); + xfer += (*(this->success))[_i827].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size832; - ::apache::thrift::protocol::TType _etype835; - xfer += iprot->readListBegin(_etype835, _size832); - this->primaryKeys.resize(_size832); - uint32_t _i836; - for (_i836 = 0; _i836 < _size832; ++_i836) + uint32_t _size828; + ::apache::thrift::protocol::TType _etype831; + xfer += iprot->readListBegin(_etype831, _size828); + this->primaryKeys.resize(_size828); + uint32_t _i832; + for (_i832 = 0; _i832 < _size828; ++_i832) { - xfer += this->primaryKeys[_i836].read(iprot); + xfer += this->primaryKeys[_i832].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size837; - ::apache::thrift::protocol::TType _etype840; - xfer += iprot->readListBegin(_etype840, _size837); - this->foreignKeys.resize(_size837); - uint32_t _i841; - for (_i841 = 0; _i841 < _size837; ++_i841) + uint32_t _size833; + ::apache::thrift::protocol::TType _etype836; + xfer += iprot->readListBegin(_etype836, _size833); + this->foreignKeys.resize(_size833); + uint32_t _i837; + for (_i837 = 0; _i837 < _size833; ++_i837) { - xfer += this->foreignKeys[_i841].read(iprot); + xfer += this->foreignKeys[_i837].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,10 +4578,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter842; - for (_iter842 = this->primaryKeys.begin(); _iter842 != this->primaryKeys.end(); ++_iter842) + std::vector<SQLPrimaryKey> ::const_iterator _iter838; + for (_iter838 = this->primaryKeys.begin(); _iter838 != this->primaryKeys.end(); ++_iter838) { - xfer += (*_iter842).write(oprot); + xfer += (*_iter838).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4590,10 +4590,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter843; - for (_iter843 = this->foreignKeys.begin(); _iter843 != this->foreignKeys.end(); ++_iter843) + std::vector<SQLForeignKey> ::const_iterator _iter839; + for (_iter839 = this->foreignKeys.begin(); _iter839 != this->foreignKeys.end(); ++_iter839) { - xfer += (*_iter843).write(oprot); + xfer += (*_iter839).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4621,10 +4621,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter844; - for (_iter844 = (*(this->primaryKeys)).begin(); _iter844 != (*(this->primaryKeys)).end(); ++_iter844) + std::vector<SQLPrimaryKey> ::const_iterator _iter840; + for (_iter840 = (*(this->primaryKeys)).begin(); _iter840 != (*(this->primaryKeys)).end(); ++_iter840) { - xfer += (*_iter844).write(oprot); + xfer += (*_iter840).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4633,10 +4633,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size())); - std::vector<SQLForeignKey> ::const_iterator _iter845; - for (_iter845 = (*(this->foreignKeys)).begin(); _iter845 != (*(this->foreignKeys)).end(); ++_iter845) + std::vector<SQLForeignKey> ::const_iterator _iter841; + for (_iter841 = (*(this->foreignKeys)).begin(); _iter841 != (*(this->foreignKeys)).end(); ++_iter841) { - xfer += (*_iter845).write(oprot); + xfer += (*_iter841).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5641,14 +5641,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size846; - ::apache::thrift::protocol::TType _etype849; - xfer += iprot->readListBegin(_etype849, _size846); - this->success.resize(_size846); - uint32_t _i850; - for (_i850 = 0; _i850 < _size846; ++_i850) + uint32_t _size842; + ::apache::thrift::protocol::TType _etype845; + xfer += iprot->readListBegin(_etype845, _size842); + this->success.resize(_size842); + uint32_t _i846; + for (_i846 = 0; _i846 < _size842; ++_i846) { - xfer += iprot->readString(this->success[_i850]); + xfer += iprot->readString(this->success[_i846]); } xfer += iprot->readListEnd(); } @@ -5687,10 +5687,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 _iter851; - for (_iter851 = this->success.begin(); _iter851 != this->success.end(); ++_iter851) + std::vector<std::string> ::const_iterator _iter847; + for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847) { - xfer += oprot->writeString((*_iter851)); + xfer += oprot->writeString((*_iter847)); } xfer += oprot->writeListEnd(); } @@ -5735,14 +5735,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size852; - ::apache::thrift::protocol::TType _etype855; - xfer += iprot->readListBegin(_etype855, _size852); - (*(this->success)).resize(_size852); - uint32_t _i856; - for (_i856 = 0; _i856 < _size852; ++_i856) + uint32_t _size848; + ::apache::thrift::protocol::TType _etype851; + xfer += iprot->readListBegin(_etype851, _size848); + (*(this->success)).resize(_size848); + uint32_t _i852; + for (_i852 = 0; _i852 < _size848; ++_i852) { - xfer += iprot->readString((*(this->success))[_i856]); + xfer += iprot->readString((*(this->success))[_i852]); } xfer += iprot->readListEnd(); } @@ -5817,14 +5817,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size857; - ::apache::thrift::protocol::TType _etype860; - xfer += iprot->readListBegin(_etype860, _size857); - this->tbl_types.resize(_size857); - uint32_t _i861; - for (_i861 = 0; _i861 < _size857; ++_i861) + uint32_t _size853; + ::apache::thrift::protocol::TType _etype856; + xfer += iprot->readListBegin(_etype856, _size853); + this->tbl_types.resize(_size853); + uint32_t _i857; + for (_i857 = 0; _i857 < _size853; ++_i857) { - xfer += iprot->readString(this->tbl_types[_i861]); + xfer += iprot->readString(this->tbl_types[_i857]); } xfer += iprot->readListEnd(); } @@ -5861,10 +5861,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc 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 _iter862; - for (_iter862 = this->tbl_types.begin(); _iter862 != this->tbl_types.end(); ++_iter862) + std::vector<std::string> ::const_iterator _iter858; + for (_iter858 = this->tbl_types.begin(); _iter858 != this->tbl_types.end(); ++_iter858) { - xfer += oprot->writeString((*_iter862)); + xfer += oprot->writeString((*_iter858)); } xfer += oprot->writeListEnd(); } @@ -5896,10 +5896,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto 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 _iter863; - for (_iter863 = (*(this->tbl_types)).begin(); _iter863 != (*(this->tbl_types)).end(); ++_iter863) + std::vector<std::string> ::const_iterator _iter859; + for (_iter859 = (*(this->tbl_types)).begin(); _iter859 != (*(this->tbl_types)).end(); ++_iter859) { - xfer += oprot->writeString((*_iter863)); + xfer += oprot->writeString((*_iter859)); } xfer += oprot->writeListEnd(); } @@ -5940,14 +5940,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size864; - ::apache::thrift::protocol::TType _etype867; - xfer += iprot->readListBegin(_etype867, _size864); - this->success.resize(_size864); - uint32_t _i868; - for (_i868 = 0; _i868 < _size864; ++_i868) + uint32_t _size860; + ::apache::thrift::protocol::TType _etype863; + xfer += iprot->readListBegin(_etype863, _size860); + this->success.resize(_size860); + uint32_t _i864; + for (_i864 = 0; _i864 < _size860; ++_i864) { - xfer += this->success[_i868].read(iprot); + xfer += this->success[_i864].read(iprot); } xfer += iprot->readListEnd(); } @@ -5986,10 +5986,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_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<TableMeta> ::const_iterator _iter869; - for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) + std::vector<TableMeta> ::const_iterator _iter865; + for (_iter865 = this->success.begin(); _iter865 != this->success.end(); ++_iter865) { - xfer += (*_iter869).write(oprot); + xfer += (*_iter865).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6034,14 +6034,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size870; - ::apache::thrift::protocol::TType _etype873; - xfer += iprot->readListBegin(_etype873, _size870); - (*(this->success)).resize(_size870); - uint32_t _i874; - for (_i874 = 0; _i874 < _size870; ++_i874) + uint32_t _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + (*(this->success)).resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += (*(this->success))[_i874].read(iprot); + xfer += (*(this->success))[_i870].read(iprot); } xfer += iprot->readListEnd(); } @@ -6179,14 +6179,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size875; - ::apache::thrift::protocol::TType _etype878; - xfer += iprot->readListBegin(_etype878, _size875); - this->success.resize(_size875); - uint32_t _i879; - for (_i879 = 0; _i879 < _size875; ++_i879) + uint32_t _size871; + ::apache::thrift::protocol::TType _etype874; + xfer += iprot->readListBegin(_etype874, _size871); + this->success.resize(_size871); + uint32_t _i875; + for (_i875 = 0; _i875 < _size871; ++_i875) { - xfer += iprot->readString(this->success[_i879]); + xfer += iprot->readString(this->success[_i875]); } xfer += iprot->readListEnd(); } @@ -6225,10 +6225,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 _iter880; - for (_iter880 = this->success.begin(); _iter880 != this->success.end(); ++_iter880) + std::vector<std::string> ::const_iterator _iter876; + for (_iter876 = this->success.begin(); _iter876 != this->success.end(); ++_iter876) { - xfer += oprot->writeString((*_iter880)); + xfer += oprot->writeString((*_iter876)); } xfer += oprot->writeListEnd(); } @@ -6273,14 +6273,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size881; - ::apache::thrift::protocol::TType _etype884; - xfer += iprot->readListBegin(_etype884, _size881); - (*(this->success)).resize(_size881); - uint32_t _i885; - for (_i885 = 0; _i885 < _size881; ++_i885) + uint32_t _size877; + ::apache::thrift::protocol::TType _etype880; + xfer += iprot->readListBegin(_etype880, _size877); + (*(this->success)).resize(_size877); + uint32_t _i881; + for (_i881 = 0; _i881 < _size877; ++_i881) { - xfer += iprot->readString((*(this->success))[_i885]); + xfer += iprot->readString((*(this->success))[_i881]); } xfer += iprot->readListEnd(); } @@ -6590,14 +6590,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 _size886; - ::apache::thrift::protocol::TType _etype889; - xfer += iprot->readListBegin(_etype889, _size886); - this->tbl_names.resize(_size886); - uint32_t _i890; - for (_i890 = 0; _i890 < _size886; ++_i890) + uint32_t _size882; + ::apache::thrift::protocol::TType _etype885; + xfer += iprot->readListBegin(_etype885, _size882); + this->tbl_names.resize(_size882); + uint32_t _i886; + for (_i886 = 0; _i886 < _size882; ++_i886) { - xfer += iprot->readString(this->tbl_names[_i890]); + xfer += iprot->readString(this->tbl_names[_i886]); } xfer += iprot->readListEnd(); } @@ -6630,10 +6630,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 _iter891; - for (_iter891 = this->tbl_names.begin(); _iter891 != this->tbl_names.end(); ++_iter891) + std::vector<std::string> ::const_iterator _iter887; + for (_iter887 = this->tbl_names.begin(); _iter887 != this->tbl_names.end(); ++_iter887) { - xfer += oprot->writeString((*_iter891)); + xfer += oprot->writeString((*_iter887)); } xfer += oprot->writeListEnd(); } @@ -6661,10 +6661,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 _iter892; - for (_iter892 = (*(this->tbl_names)).begin(); _iter892 != (*(this->tbl_names)).end(); ++_iter892) + std::vector<std::string> ::const_iterator _iter888; + for (_iter888 = (*(this->tbl_names)).begin(); _iter888 != (*(this->tbl_names)).end(); ++_iter888) { - xfer += oprot->writeString((*_iter892)); + xfer += oprot->writeString((*_iter888)); } xfer += oprot->writeListEnd(); } @@ -6705,14 +6705,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 _size893; - ::apache::thrift::protocol::TType _etype896; - xfer += iprot->readListBegin(_etype896, _size893); - this->success.resize(_size893); - uint32_t _i897; - for (_i897 = 0; _i897 < _size893; ++_i897) + uint32_t _size889; + ::apache::thrift::protocol::TType _etype892; + xfer += iprot->readListBegin(_etype892, _size889); + this->success.resize(_size889); + uint32_t _i893; + for (_i893 = 0; _i893 < _size889; ++_i893) { - xfer += this->success[_i897].read(iprot); + xfer += this->success[_i893].read(iprot); } xfer += iprot->readListEnd(); } @@ -6767,10 +6767,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 _iter898; - for (_iter898 = this->success.begin(); _iter898 != this->success.end(); ++_iter898) + std::vector<Table> ::const_iterator _iter894; + for (_iter894 = this->success.begin(); _iter894 != this->success.end(); ++_iter894) { - xfer += (*_iter898).write(oprot); + xfer += (*_iter894).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6823,14 +6823,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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - (*(this->success)).resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size895; + ::apache::thrift::protocol::TType _etype898; + xfer += iprot->readListBegin(_etype898, _size895); + (*(this->success)).resize(_size895); + uint32_t _i899; + for (_i899 = 0; _i899 < _size895; ++_i899) { - xfer += (*(this->success))[_i903].read(iprot); + xfer += (*(this->success))[_i899].read(iprot); } xfer += iprot->readListEnd(); } @@ -7016,14 +7016,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 _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->success.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size900; + ::apache::thrift::protocol::TType _etype903; + xfer += iprot->readListBegin(_etype903, _size900); + this->success.resize(_size900); + uint32_t _i904; + for (_i904 = 0; _i904 < _size900; ++_i904) { - xfer += iprot->readString(this->success[_i908]); + xfer += iprot->readString(this->success[_i904]); } xfer += iprot->readListEnd(); } @@ -7078,10 +7078,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 _iter909; - for (_iter909 = this->success.begin(); _iter909 != this->success.end(); ++_iter909) + std::vector<std::string> ::const_iterator _iter905; + for (_iter905 = this->success.begin(); _iter905 != this->success.end(); ++_iter905) { - xfer += oprot->writeString((*_iter909)); + xfer += oprot->writeString((*_iter905)); } xfer += oprot->writeListEnd(); } @@ -7134,14 +7134,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 _size910; - ::apache::thrift::protocol::TType _etype913; - xfer += iprot->readListBegin(_etype913, _size910); - (*(this->success)).resize(_size910); - uint32_t _i914; - for (_i914 = 0; _i914 < _size910; ++_i914) + uint32_t _size906; + ::apache::thrift::protocol::TType _etype909; + xfer += iprot->readListBegin(_etype909, _size906); + (*(this->success)).resize(_size906); + uint32_t _i910; + for (_i910 = 0; _i910 < _size906; ++_i910) { - xfer += iprot->readString((*(this->success))[_i914]); + xfer += iprot->readString((*(this->success))[_i910]); } xfer += iprot->readListEnd(); } @@ -8475,14 +8475,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size915; - ::apache::thrift::protocol::TType _etype918; - xfer += iprot->readListBegin(_etype918, _size915); - this->new_parts.resize(_size915); - uint32_t _i919; - for (_i919 = 0; _i919 < _size915; ++_i919) + uint32_t _size911; + ::apache::thrift::protocol::TType _etype914; + xfer += iprot->readListBegin(_etype914, _size911); + this->new_parts.resize(_size911); + uint32_t _i915; + for (_i915 = 0; _i915 < _size911; ++_i915) { - xfer += this->new_parts[_i919].read(iprot); + xfer += this->new_parts[_i915].read(iprot); } xfer += iprot->readListEnd(); } @@ -8511,10 +8511,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 _iter920; - for (_iter920 = this->new_parts.begin(); _iter920 != this->new_parts.end(); ++_iter920) + std::vector<Partition> ::const_iterator _iter916; + for (_iter916 = this->new_parts.begin(); _iter916 != this->new_parts.end(); ++_iter916) { - xfer += (*_iter920).write(oprot); + xfer += (*_iter916).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8538,10 +8538,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 _iter921; - for (_iter921 = (*(this->new_parts)).begin(); _iter921 != (*(this->new_parts)).end(); ++_iter921) + std::vector<Partition> ::const_iterator _iter917; + for (_iter917 = (*(this->new_parts)).begin(); _iter917 != (*(this->new_parts)).end(); ++_iter917) { - xfer += (*_iter921).write(oprot); + xfer += (*_iter917).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8750,14 +8750,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 _size922; - ::apache::thrift::protocol::TType _etype925; - xfer += iprot->readListBegin(_etype925, _size922); - this->new_parts.resize(_size922); - uint32_t _i926; - for (_i926 = 0; _i926 < _size922; ++_i926) + uint32_t _size918; + ::apache::thrift::protocol::TType _etype921; + xfer += iprot->readListBegin(_etype921, _size918); + this->new_parts.resize(_size918); + uint32_t _i922; + for (_i922 = 0; _i922 < _size918; ++_i922) { - xfer += this->new_parts[_i926].read(iprot); + xfer += this->new_parts[_i922].read(iprot); } xfer += iprot->readListEnd(); } @@ -8786,10 +8786,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 _iter927; - for (_iter927 = this->new_parts.begin(); _iter927 != this->new_parts.end(); ++_iter927) + std::vector<PartitionSpec> ::const_iterator _iter923; + for (_iter923 = this->new_parts.begin(); _iter923 != this->new_parts.end(); ++_iter923) { - xfer += (*_iter927).write(oprot); + xfer += (*_iter923).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8813,10 +8813,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 _iter928; - for (_iter928 = (*(this->new_parts)).begin(); _iter928 != (*(this->new_parts)).end(); ++_iter928) + std::vector<PartitionSpec> ::const_iterator _iter924; + for (_iter924 = (*(this->new_parts)).begin(); _iter924 != (*(this->new_parts)).end(); ++_iter924) { - xfer += (*_iter928).write(oprot); + xfer += (*_iter924).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9041,14 +9041,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size929; - ::apache::thrift::protocol::TType _etype932; - xfer += iprot->readListBegin(_etype932, _size929); - this->part_vals.resize(_size929); - uint32_t _i933; - for (_i933 = 0; _i933 < _size929; ++_i933) + uint32_t _size925; + ::apache::thrift::protocol::TType _etype928; + xfer += iprot->readListBegin(_etype928, _size925); + this->part_vals.resize(_size925); + uint32_t _i929; + for (_i929 = 0; _i929 < _size925; ++_i929) { - xfer += iprot->readString(this->part_vals[_i933]); + xfer += iprot->readString(this->part_vals[_i929]); } xfer += iprot->readListEnd(); } @@ -9085,10 +9085,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 _iter934; - for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter930; + for (_iter930 = this->part_vals.begin(); _iter930 != this->part_vals.end(); ++_iter930) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter930)); } xfer += oprot->writeListEnd(); } @@ -9120,10 +9120,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 _iter935; - for (_iter935 = (*(this->part_vals)).begin(); _iter935 != (*(this->part_vals)).end(); ++_iter935) + std::vector<std::string> ::const_iterator _iter931; + for (_iter931 = (*(this->part_vals)).begin(); _iter931 != (*(this->part_vals)).end(); ++_iter931) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter931)); } xfer += oprot->writeListEnd(); } @@ -9595,14 +9595,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size936; - ::apache::thrift::protocol::TType _etype939; - xfer += iprot->readListBegin(_etype939, _size936); - this->part_vals.resize(_size936); - uint32_t _i940; - for (_i940 = 0; _i940 < _size936; ++_i940) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + this->part_vals.resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += iprot->readString(this->part_vals[_i940]); + xfer += iprot->readString(this->part_vals[_i936]); } xfer += iprot->readListEnd(); } @@ -9647,10 +9647,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 _iter941; - for (_iter941 = this->part_vals.begin(); _iter941 != this->part_vals.end(); ++_iter941) + std::vector<std::string> ::const_iterator _iter937; + for (_iter937 = this->part_vals.begin(); _iter937 != this->part_vals.end(); ++_iter937) { - xfer += oprot->writeString((*_iter941)); + xfer += oprot->writeString((*_iter937)); } xfer += oprot->writeListEnd(); } @@ -9686,10 +9686,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 _iter942; - for (_iter942 = (*(this->part_vals)).begin(); _iter942 != (*(this->part_vals)).end(); ++_iter942) + std::vector<std::string> ::const_iterator _iter938; + for (_iter938 = (*(this->part_vals)).begin(); _iter938 != (*(this->part_vals)).end(); ++_iter938) { - xfer += oprot->writeString((*_iter942)); + xfer += oprot->writeString((*_iter938)); } xfer += oprot->writeListEnd(); } @@ -10492,14 +10492,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size943; - ::apache::thrift::protocol::TType _etype946; - xfer += iprot->readListBegin(_etype946, _size943); - this->part_vals.resize(_size943); - uint32_t _i947; - for (_i947 = 0; _i947 < _size943; ++_i947) + uint32_t _size939; + ::apache::thrift::protocol::TType _etype942; + xfer += iprot->readListBegin(_etype942, _size939); + this->part_vals.resize(_size939); + uint32_t _i943; + for (_i943 = 0; _i943 < _size939; ++_i943) { - xfer += iprot->readString(this->part_vals[_i947]); + xfer += iprot->readString(this->part_vals[_i943]); } xfer += iprot->readListEnd(); } @@ -10544,10 +10544,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 _iter948; - for (_iter948 = this->part_vals.begin(); _iter948 != this->part_vals.end(); ++_iter948) + std::vector<std::string> ::const_iterator _iter944; + for (_iter944 = this->part_vals.begin(); _iter944 != this->part_vals.end(); ++_iter944) { - xfer += oprot->writeString((*_iter948)); + xfer += oprot->writeString((*_iter944)); } xfer += oprot->writeListEnd(); } @@ -10583,10 +10583,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 _iter949; - for (_iter949 = (*(this->part_vals)).begin(); _iter949 != (*(this->part_vals)).end(); ++_iter949) + std::vector<std::string> ::const_iterator _iter945; + for (_iter945 = (*(this->part_vals)).begin(); _iter945 != (*(this->part_vals)).end(); ++_iter945) { - xfer += oprot->writeString((*_iter949)); + xfer += oprot->writeString((*_iter945)); } xfer += oprot->writeListEnd(); } @@ -10795,14 +10795,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size950; - ::apache::thrift::protocol::TType _etype953; - xfer += iprot->readListBegin(_etype953, _size950); - this->part_vals.resize(_size950); - uint32_t _i954; - for (_i954 = 0; _i954 < _size950; ++_i954) + uint32_t _size946; + ::apache::thrift::protocol::TType _etype949; + xfer += iprot->readListBegin(_etype949, _size946); + this->part_vals.resize(_size946); + uint32_t _i950; + for (_i950 = 0; _i950 < _size946; ++_i950) { - xfer += iprot->readString(this->part_vals[_i954]); + xfer += iprot->readString(this->part_vals[_i950]); } xfer += iprot->readListEnd(); } @@ -10855,10 +10855,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 _iter955; - for (_iter955 = this->part_vals.begin(); _iter955 != this->part_vals.end(); ++_iter955) + std::vector<std::string> ::const_iterator _iter951; + for (_iter951 = this->part_vals.begin(); _iter951 != this->part_vals.end(); ++_iter951) { - xfer += oprot->writeString((*_iter955)); + xfer += oprot->writeString((*_iter951)); } xfer += oprot->writeListEnd(); } @@ -10898,10 +10898,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 _iter956; - for (_iter956 = (*(this->part_vals)).begin(); _iter956 != (*(this->part_vals)).end(); ++_iter956) + std::vector<std::string> ::const_iterator _iter952; + for (_iter952 = (*(this->part_vals)).begin(); _iter952 != (*(this->part_vals)).end(); ++_iter952) { - xfer += oprot->writeString((*_iter956)); + xfer += oprot->writeString((*_iter952)); } xfer += oprot->writeListEnd(); } @@ -11907,14 +11907,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size957; - ::apache::thrift::protocol::TType _etype960; - xfer += iprot->readListBegin(_etype960, _size957); - this->part_vals.resize(_size957); - uint32_t _i961; - for (_i961 = 0; _i961 < _size957; ++_i961) + uint32_t _size953; + ::apache::thrift::protocol::TType _etype956; + xfer += iprot->readListBegin(_etype956, _size953); + this->part_vals.resize(_size953); + uint32_t _i957; + for (_i957 = 0; _i957 < _size953; ++_i957) { - xfer += iprot->readString(this->part_vals[_i961]); + xfer += iprot->readString(this->part_vals[_i957]); } xfer += iprot->readListEnd(); } @@ -11951,10 +11951,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 _iter962; - for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) + std::vector<std::string> ::const_iterator _iter958; + for (_iter958 = this->part_vals.begin(); _iter958 != this->part_vals.end(); ++_iter958) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter958)); } xfer += oprot->writeListEnd(); } @@ -11986,10 +11986,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 _iter963; - for (_iter963 = (*(this->part_vals)).begin(); _iter963 != (*(this->part_vals)).end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter959; + for (_iter959 = (*(this->part_vals)).begin(); _iter959 != (*(this->part_vals)).end(); ++_iter959) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter959)); } xfer += oprot->writeListEnd(); } @@ -12178,17 +12178,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _ktype965; - ::apache::thrift::protocol::TType _vtype966; - xfer += iprot->readMapBegin(_ktype965, _vtype966, _size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size960; + ::apache::thrift::protocol::TType _ktype961; + ::apache::thrift::protocol::TType _vtype962; + xfer += iprot->readMapBegin(_ktype961, _vtype962, _size960); + uint32_t _i964; + for (_i964 = 0; _i964 < _size960; ++_i964) { - std::string _key969; - xfer += iprot->readString(_key969); - std::string& _val970 = this->partitionSpecs[_key969]; - xfer += iprot->readString(_val970); + std::string _key965; + xfer += iprot->readString(_key965); + std::string& _val966 = this->partitionSpecs[_key965]; + xfer += iprot->readString(_val966); } xfer += iprot->readMapEnd(); } @@ -12249,11 +12249,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 _iter971; - for (_iter971 = this->partitionSpecs.begin(); _iter971 != this->partitionSpecs.end(); ++_iter971) + std::map<std::string, std::string> ::const_iterator _iter967; + for (_iter967 = this->partitionSpecs.begin(); _iter967 != this->partitionSpecs.end(); ++_iter967) { - xfer += oprot->writeString(_iter971->first); - xfer += oprot->writeString(_iter971->second); + xfer += oprot->writeString(_iter967->first); + xfer += oprot->writeString(_iter967->second); } xfer += oprot->writeMapEnd(); } @@ -12293,11 +12293,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 _iter972; - for (_iter972 = (*(this->partitionSpecs)).begin(); _iter972 != (*(this->partitionSpecs)).end(); ++_iter972) + std::map<std::string, std::string> ::const_iterator _iter968; + for (_iter968 = (*(this->partitionSpecs)).begin(); _iter968 != (*(this->partitionSpecs)).end(); ++_iter968) { - xfer += oprot->writeString(_iter972->first); - xfer += oprot->writeString(_iter972->second); + xfer += oprot->writeString(_iter968->first); + xfer += oprot->writeString(_iter968->second); } xfer += oprot->writeMapEnd(); } @@ -12542,17 +12542,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size973; - ::apache::thrift::protocol::TType _ktype974; - ::apache::thrift::protocol::TType _vtype975; - xfer += iprot->readMapBegin(_ktype974, _vtype975, _size973); - uint32_t _i977; - for (_i977 = 0; _i977 < _size973; ++_i977) + uint32_t _size969; + ::apache::thrift::protocol::TType _ktype970; + ::apache::thrift::protocol::TType _vtype971; + xfer += iprot->readMapBegin(_ktype970, _vtype971, _size969); + uint32_t _i973; + for (_i973 = 0; _i973 < _size969; ++_i973) { - std::string _key978; - xfer += iprot->readString(_key978); - std::string& _val979 = this->partitionSpecs[_key978]; - xfer += iprot->readString(_val979); + std::string _key974; + xfer += iprot->readString(_key974); + std::string& _val975 = this->partitionSpecs[_key974]; + xfer += iprot->readString(_val975); } xfer += iprot->readMapEnd(); } @@ -12613,11 +12613,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 _iter980; - for (_iter980 = this->partitionSpecs.begin(); _iter980 != this->partitionSpecs.end(); ++_iter980) + std::map<std::string, std::string> ::const_iterator _iter976; + for (_iter976 = this->partitionSpecs.begin(); _iter976 != this->partitionSpecs.end(); ++_iter976) { - xfer += oprot->writeString(_iter980->first); - xfer += oprot->writeString(_iter980->second); + xfer += oprot->writeString(_iter976->first); + xfer += oprot->writeString(_iter976->second); } xfer += oprot->writeMapEnd(); } @@ -12657,11 +12657,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 _iter981; - for (_iter981 = (*(this->partitionSpecs)).begin(); _iter981 != (*(this->partitionSpecs)).end(); ++_iter981) + std::map<std::string, std::string> ::const_iterator _iter977; + for (_iter977 = (*(this->partitionSpecs)).begin(); _iter977 != (*(this->partitionSpecs)).end(); ++_iter977) { - xfer += oprot->writeString(_iter981->first); - xfer += oprot->writeString(_iter981->second); + xfer += oprot->writeString(_iter977->first); + xfer += oprot->writeString(_iter977->second); } xfer += oprot->writeMapEnd(); } @@ -12718,14 +12718,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - this->success.resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size978; + ::apache::thrift::protocol::TType _etype981; + xfer += iprot->readListBegin(_etype981, _size978); + this->success.resize(_size978); + uint32_t _i982; + for (_i982 = 0; _i982 < _size978; ++_i982) { - xfer += this->success[_i986].read(iprot); + xfer += this->success[_i982].read(iprot); } xfer += iprot->readListEnd(); } @@ -12788,10 +12788,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 _iter987; - for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) + std::vector<Partition> ::const_iterator _iter983; + for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) { - xfer += (*_iter987).write(oprot); + xfer += (*_iter983).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12848,14 +12848,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size988; - ::apache::thrift::protocol::TType _etype991; - xfer += iprot->readListBegin(_etype991, _size988); - (*(this->success)).resize(_size988); - uint32_t _i992; - for (_i992 = 0; _i992 < _size988; ++_i992) + 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) { - xfer += (*(this->success))[_i992].read(iprot); + xfer += (*(this->success))[_i988].read(iprot); } xfer += iprot->readListEnd(); } @@ -12954,14 +12954,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 _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->part_vals.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size989; + ::apache::thrift::protocol::TType _etype992; + xfer += iprot->readListBegin(_etype992, _size989); + this->part_vals.resize(_size989); + uint32_t _i993; + for (_i993 = 0; _i993 < _size989; ++_i993) { - xfer += iprot->readString(this->part_vals[_i997]); + xfer += iprot->readString(this->part_vals[_i993]); } xfer += iprot->readListEnd(); } @@ -12982,14 +12982,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 _size998; - ::apache::thrift::protocol::TType _etype1001; - xfer += iprot->readListBegin(_etype1001, _size998); - this->group_names.resize(_size998); - uint32_t _i1002; - for (_i1002 = 0; _i1002 < _size998; ++_i1002) + uint32_t _size994; + ::apache::thrift::protocol::TType _etype997; + xfer += iprot->readListBegin(_etype997, _size994); + this->group_names.resize(_size994); + uint32_t _i998; + for (_i998 = 0; _i998 < _size994; ++_i998) { - xfer += iprot->readString(this->group_names[_i1002]); + xfer += iprot->readString(this->group_names[_i998]); } xfer += iprot->readListEnd(); } @@ -13026,10 +13026,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 _iter1003; - for (_iter1003 = this->part_vals.begin(); _iter1003 != this->part_vals.end(); ++_iter1003) + std::vector<std::string> ::const_iterator _iter999; + for (_iter999 = this->part_vals.begin(); _iter999 != this->part_vals.end(); ++_iter999) { - xfer += oprot->writeString((*_iter1003)); + xfer += oprot->writeString((*_iter999)); } xfer += oprot->writeListEnd(); } @@ -13042,10 +13042,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 _iter1004; - for (_iter1004 = this->group_names.begin(); _iter1004 != this->group_names.end(); ++_iter1004) + std::vector<std::string> ::const_iterator _iter1000; + for (_iter1000 = this->group_names.begin(); _iter1000 != this->group_names.end(); ++_iter1000) { - xfer += oprot->writeString((*_iter1004)); + xfer += oprot->writeString((*_iter1000)); } xfer += oprot->writeListEnd(); } @@ -13077,10 +13077,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 _iter1005; - for (_iter1005 = (*(this->part_vals)).begin(); _iter1005 != (*(this->part_vals)).end(); ++_iter1005) + std::vector<std::string> ::const_iterator _iter1001; + for (_iter1001 = (*(this->part_vals)).begin(); _iter1001 != (*(this->part_vals)).end(); ++_iter1001) { - xfer += oprot->writeString((*_iter1005)); + xfer += oprot->writeString((*_iter1001)); } xfer += oprot->writeListEnd(); } @@ -13093,10 +13093,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 _iter1006; - for (_iter1006 = (*(this->group_names)).begin(); _iter1006 != (*(this->group_names)).end(); ++_iter1006) + std::vector<std::string> ::const_iterator _iter1002; + for (_iter1002 = (*(this->group_names)).begin(); _iter1002 != (*(this->group_names)).end(); ++_iter1002) { - xfer += oprot->writeString((*_iter1006)); + xfer += oprot->writeString((*_iter1002)); } xfer += oprot->writeListEnd(); } @@ -13655,14 +13655,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->success.resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1003; + ::apache::thrift::protocol::TType _etype1006; + xfer += iprot->readListBegin(_etype1006, _size1003); + this->success.resize(_size1003); + uint32_t _i1007; + for (_i1007 = 0; _i1007 < _size1003; ++_i1007) { - xfer += this->success[_i1011].read(iprot); + xfer += this->success[_i1007].read(iprot); } xfer += iprot->readListEnd(); } @@ -13709,10 +13709,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 _iter1012; - for (_iter1012 = this->success.begin(); _iter1012 != this->success.end(); ++_iter1012) + std::vector<Partition> ::const_iterator _iter1008; + for (_iter1008 = this->success.begin(); _iter1008 != this->success.end(); ++_iter1008) { - xfer += (*_iter1012).write(oprot); + xfer += (*_iter1008).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13761,14 +13761,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1013; - ::apache::thrift::protocol::TType _etype1016; - xfer += iprot->readListBegin(_etype1016, _size1013); - (*(this->success)).resize(_size1013); - uint32_t _i1017; - for (_i1017 = 0; _i1017 < _size1013; ++_i1017) + uint32_t _size1009; + ::apache::thrift::protocol::TType _etype1012; + xfer += iprot->readListBegin(_etype1012, _size1009); + (*(this->success)).resize(_size1009); + uint32_t _i1013; + for (_i1013 = 0; _i1013 < _size1009; ++_i1013) { - xfer += (*(this->success))[_i1017].read(iprot); + xfer += (*(this->success))[_i1013].read(iprot); } xfer += iprot->readListEnd(); } @@ -13867,14 +13867,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 _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - this->group_names.resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1014; + ::apache::thrift::protocol::TType _etype1017; + xfer += iprot->readListBegin(_etype1017, _size1014); + this->group_names.resize(_size1014); + uint32_t _i1018; + for (_i1018 = 0; _i1018 < _size1014; ++_i1018) { - xfer += iprot->readString(this->group_names[_i1022]); + xfer += iprot->readString(this->group_names[_i1018]); } xfer += iprot->readListEnd(); } @@ -13919,10 +13919,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 _iter1023; - for (_iter1023 = this->group_names.begin(); _iter1023 != this->group_names.end(); ++_iter1023) + std::vector<std::string> ::const_iterator _iter1019; + for (_iter1019 = this->group_names.begin(); _iter1019 != this->group_names.end(); ++_iter1019) { - xfer += oprot->writeString((*_iter1023)); + xfer += oprot->writeString((*_iter1019)); } xfer += oprot->writeListEnd(); } @@ -13962,10 +13962,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 _iter1024; - for (_iter1024 = (*(this->group_names)).begin(); _iter1024 != (*(this->group_names)).end(); ++_iter1024) + std::vector<std::string> ::const_iterator _iter1020; + for (_iter1020 = (*(this->group_names)).begin(); _iter1020 != (*(this->group_names)).end(); ++_iter1020) { - xfer += oprot->writeString((*_iter1024)); + xfer += oprot->writeString((*_iter1020)); } xfer += oprot->writeListEnd(); } @@ -14006,14 +14006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1025; - ::apache::thrift::protocol::TType _etype1028; - xfer += iprot->readListBegin(_etype1028, _size1025); - this->success.resize(_size1025); - uint32_t _i1029; - for (_i1029 = 0; _i1029 < _size1025; ++_i1029) + uint32_t _size1021; + ::apache::thrift::protocol::TType _etype1024; + xfer += iprot->readListBegin(_etype1024, _size1021); + this->success.resize(_size1021); + uint32_t _i1025; + for (_i1025 = 0; _i1025 < _size1021; ++_i1025) { - xfer += this->success[_i1029].read(iprot); + xfer += this->success[_i1025].read(iprot); } xfer += iprot->readListEnd(); } @@ -14060,10 +14060,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 _iter1030; - for (_iter1030 = this->success.begin(); _iter1030 != this->success.end(); ++_iter1030) + std::vector<Partition> ::const_iterator _iter1026; + for (_iter1026 = this->success.begin(); _iter1026 != this->success.end(); ++_iter1026) { - xfer += (*_iter1030).write(oprot); + xfer += (*_iter1026).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14112,14 +14112,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1031; - ::apache::thrift::protocol::TType _etype1034; - xfer += iprot->readListBegin(_etype1034, _size1031); - (*(this->success)).resize(_size1031); - uint32_t _i1035; - for (_i1035 = 0; _i1035 < _size1031; ++_i1035) + uint32_t _size1027; + ::apache::thrift::protocol::TType _etype1030; + xfer += iprot->readListBegin(_etype1030, _size1027); + (*(this->success)).resize(_size1027); + uint32_t _i1031; + for (_i1031 = 0; _i1031 < _size1027; ++_i1031) { - xfer += (*(this->success))[_i1035].read(iprot); + xfer += (*(this->success))[_i1031].read(iprot); } xfer += iprot->readListEnd(); } @@ -14297,14 +14297,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1036; - ::apache::thrift::protocol::TType _etype1039; - xfer += iprot->readListBegin(_etype1039, _size1036); - this->success.resize(_size1036); - uint32_t _i1040; - for (_i1040 = 0; _i1040 < _size1036; ++_i1040) + uint32_t _size1032; + ::apache::thrift::protocol::TType _etype1035; + xfer += iprot->readListBegin(_etype1035, _size1032); + this->success.resize(_size1032); + uint32_t _i1036; + for (_i1036 = 0; _i1036 < _size1032; ++_i1036) { - xfer += this->success[_i1040].read(iprot); + xfer += this->success[_i1036].read(iprot); } xfer += iprot->readListEnd(); } @@ -14351,10 +14351,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 _iter1041; - for (_iter1041 = this->success.begin(); _iter1041 != this->success.end(); ++_iter1041) + std::vector<PartitionSpec> ::const_iterator _iter1037; + for (_iter1037 = this->success.begin(); _iter1037 != this->success.end(); ++_iter1037) { - xfer += (*_iter1041).write(oprot); + xfer += (*_iter1037).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14403,14 +14403,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _etype1045; - xfer += iprot->readListBegin(_etype1045, _size1042); - (*(this->success)).resize(_size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1038; + ::apache::thrift::protocol::TType _etype1041; + xfer += iprot->readListBegin(_etype1041, _size1038); + (*(this->success)).resize(_size1038); + uint32_t _i1042; + for (_i1042 = 0; _i1042 < _size1038; ++_i1042) { - xfer += (*(this->success))[_i1046].read(iprot); + xfer += (*(this->success))[_i1042].read(iprot); } xfer += iprot->readListEnd(); } @@ -14588,14 +14588,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1047; - ::apache::thrift::protocol::TType _etype1050; - xfer += iprot->readListBegin(_etype1050, _size1047); - this->success.resize(_size1047); - uint32_t _i1051; - for (_i1051 = 0; _i1051 < _size1047; ++_i1051) + uint32_t _size1043; + ::apache::thrift::protocol::TType _etype1046; + xfer += iprot->readListBegin(_etype1046, _size1043); + this->success.resize(_size1043); + uint32_t _i1047; + for (_i1047 = 0; _i1047 < _size1043; ++_i1047) { - xfer += iprot->readString(this->success[_i1051]); + xfer += iprot->readString(this->success[_i1047]); } xfer += iprot->readListEnd(); } @@ -14634,10 +14634,10 @@ uint32_t ThriftHiveMetastore_get_partition_names
<TRUNCATED>