http://git-wip-us.apache.org/repos/asf/hive/blob/c57a5961/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 298384c..5a35a50 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 _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 _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 += iprot->readString(this->success[_i777]); + xfer += iprot->readString(this->success[_i785]); } 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 _iter778; - for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) + std::vector<std::string> ::const_iterator _iter786; + for (_iter786 = this->success.begin(); _iter786 != this->success.end(); ++_iter786) { - xfer += oprot->writeString((*_iter778)); + xfer += oprot->writeString((*_iter786)); } 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 _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 _size787; + ::apache::thrift::protocol::TType _etype790; + xfer += iprot->readListBegin(_etype790, _size787); + (*(this->success)).resize(_size787); + uint32_t _i791; + for (_i791 = 0; _i791 < _size787; ++_i791) { - xfer += iprot->readString((*(this->success))[_i783]); + xfer += iprot->readString((*(this->success))[_i791]); } 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 _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 _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 += iprot->readString(this->success[_i788]); + xfer += iprot->readString(this->success[_i796]); } 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 _iter789; - for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) + std::vector<std::string> ::const_iterator _iter797; + for (_iter797 = this->success.begin(); _iter797 != this->success.end(); ++_iter797) { - xfer += oprot->writeString((*_iter789)); + xfer += oprot->writeString((*_iter797)); } 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 _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 _size798; + ::apache::thrift::protocol::TType _etype801; + xfer += iprot->readListBegin(_etype801, _size798); + (*(this->success)).resize(_size798); + uint32_t _i802; + for (_i802 = 0; _i802 < _size798; ++_i802) { - xfer += iprot->readString((*(this->success))[_i794]); + xfer += iprot->readString((*(this->success))[_i802]); } 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 _size795; - ::apache::thrift::protocol::TType _ktype796; - ::apache::thrift::protocol::TType _vtype797; - xfer += iprot->readMapBegin(_ktype796, _vtype797, _size795); - uint32_t _i799; - for (_i799 = 0; _i799 < _size795; ++_i799) + uint32_t _size803; + ::apache::thrift::protocol::TType _ktype804; + ::apache::thrift::protocol::TType _vtype805; + xfer += iprot->readMapBegin(_ktype804, _vtype805, _size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - std::string _key800; - xfer += iprot->readString(_key800); - Type& _val801 = this->success[_key800]; - xfer += _val801.read(iprot); + std::string _key808; + xfer += iprot->readString(_key808); + Type& _val809 = this->success[_key808]; + xfer += _val809.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 _iter802; - for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) + std::map<std::string, Type> ::const_iterator _iter810; + for (_iter810 = this->success.begin(); _iter810 != this->success.end(); ++_iter810) { - xfer += oprot->writeString(_iter802->first); - xfer += _iter802->second.write(oprot); + xfer += oprot->writeString(_iter810->first); + xfer += _iter810->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 _size803; - ::apache::thrift::protocol::TType _ktype804; - ::apache::thrift::protocol::TType _vtype805; - xfer += iprot->readMapBegin(_ktype804, _vtype805, _size803); - uint32_t _i807; - for (_i807 = 0; _i807 < _size803; ++_i807) + uint32_t _size811; + ::apache::thrift::protocol::TType _ktype812; + ::apache::thrift::protocol::TType _vtype813; + xfer += iprot->readMapBegin(_ktype812, _vtype813, _size811); + uint32_t _i815; + for (_i815 = 0; _i815 < _size811; ++_i815) { - std::string _key808; - xfer += iprot->readString(_key808); - Type& _val809 = (*(this->success))[_key808]; - xfer += _val809.read(iprot); + std::string _key816; + xfer += iprot->readString(_key816); + Type& _val817 = (*(this->success))[_key816]; + xfer += _val817.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 _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 _size818; + ::apache::thrift::protocol::TType _etype821; + xfer += iprot->readListBegin(_etype821, _size818); + this->success.resize(_size818); + uint32_t _i822; + for (_i822 = 0; _i822 < _size818; ++_i822) { - xfer += this->success[_i814].read(iprot); + xfer += this->success[_i822].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 _iter815; - for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) + std::vector<FieldSchema> ::const_iterator _iter823; + for (_iter823 = this->success.begin(); _iter823 != this->success.end(); ++_iter823) { - xfer += (*_iter815).write(oprot); + xfer += (*_iter823).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 _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 _size824; + ::apache::thrift::protocol::TType _etype827; + xfer += iprot->readListBegin(_etype827, _size824); + (*(this->success)).resize(_size824); + uint32_t _i828; + for (_i828 = 0; _i828 < _size824; ++_i828) { - xfer += (*(this->success))[_i820].read(iprot); + xfer += (*(this->success))[_i828].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 _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 _size829; + ::apache::thrift::protocol::TType _etype832; + xfer += iprot->readListBegin(_etype832, _size829); + this->success.resize(_size829); + uint32_t _i833; + for (_i833 = 0; _i833 < _size829; ++_i833) { - xfer += this->success[_i825].read(iprot); + xfer += this->success[_i833].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 _iter826; - for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) + std::vector<FieldSchema> ::const_iterator _iter834; + for (_iter834 = this->success.begin(); _iter834 != this->success.end(); ++_iter834) { - xfer += (*_iter826).write(oprot); + xfer += (*_iter834).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 _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 _size835; + ::apache::thrift::protocol::TType _etype838; + xfer += iprot->readListBegin(_etype838, _size835); + (*(this->success)).resize(_size835); + uint32_t _i839; + for (_i839 = 0; _i839 < _size835; ++_i839) { - xfer += (*(this->success))[_i831].read(iprot); + xfer += (*(this->success))[_i839].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 _size832; - ::apache::thrift::protocol::TType _etype835; - xfer += iprot->readListBegin(_etype835, _size832); - this->success.resize(_size832); - uint32_t _i836; - for (_i836 = 0; _i836 < _size832; ++_i836) + uint32_t _size840; + ::apache::thrift::protocol::TType _etype843; + xfer += iprot->readListBegin(_etype843, _size840); + this->success.resize(_size840); + uint32_t _i844; + for (_i844 = 0; _i844 < _size840; ++_i844) { - xfer += this->success[_i836].read(iprot); + xfer += this->success[_i844].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 _iter837; - for (_iter837 = this->success.begin(); _iter837 != this->success.end(); ++_iter837) + std::vector<FieldSchema> ::const_iterator _iter845; + for (_iter845 = this->success.begin(); _iter845 != this->success.end(); ++_iter845) { - xfer += (*_iter837).write(oprot); + xfer += (*_iter845).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 _size838; - ::apache::thrift::protocol::TType _etype841; - xfer += iprot->readListBegin(_etype841, _size838); - (*(this->success)).resize(_size838); - uint32_t _i842; - for (_i842 = 0; _i842 < _size838; ++_i842) + 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) { - xfer += (*(this->success))[_i842].read(iprot); + xfer += (*(this->success))[_i850].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 _size843; - ::apache::thrift::protocol::TType _etype846; - xfer += iprot->readListBegin(_etype846, _size843); - this->success.resize(_size843); - uint32_t _i847; - for (_i847 = 0; _i847 < _size843; ++_i847) + uint32_t _size851; + ::apache::thrift::protocol::TType _etype854; + xfer += iprot->readListBegin(_etype854, _size851); + this->success.resize(_size851); + uint32_t _i855; + for (_i855 = 0; _i855 < _size851; ++_i855) { - xfer += this->success[_i847].read(iprot); + xfer += this->success[_i855].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 _iter848; - for (_iter848 = this->success.begin(); _iter848 != this->success.end(); ++_iter848) + std::vector<FieldSchema> ::const_iterator _iter856; + for (_iter856 = this->success.begin(); _iter856 != this->success.end(); ++_iter856) { - xfer += (*_iter848).write(oprot); + xfer += (*_iter856).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 _size849; - ::apache::thrift::protocol::TType _etype852; - xfer += iprot->readListBegin(_etype852, _size849); - (*(this->success)).resize(_size849); - uint32_t _i853; - for (_i853 = 0; _i853 < _size849; ++_i853) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + (*(this->success)).resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += (*(this->success))[_i853].read(iprot); + xfer += (*(this->success))[_i861].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 _size854; - ::apache::thrift::protocol::TType _etype857; - xfer += iprot->readListBegin(_etype857, _size854); - this->primaryKeys.resize(_size854); - uint32_t _i858; - for (_i858 = 0; _i858 < _size854; ++_i858) + uint32_t _size862; + ::apache::thrift::protocol::TType _etype865; + xfer += iprot->readListBegin(_etype865, _size862); + this->primaryKeys.resize(_size862); + uint32_t _i866; + for (_i866 = 0; _i866 < _size862; ++_i866) { - xfer += this->primaryKeys[_i858].read(iprot); + xfer += this->primaryKeys[_i866].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 _size859; - ::apache::thrift::protocol::TType _etype862; - xfer += iprot->readListBegin(_etype862, _size859); - this->foreignKeys.resize(_size859); - uint32_t _i863; - for (_i863 = 0; _i863 < _size859; ++_i863) + uint32_t _size867; + ::apache::thrift::protocol::TType _etype870; + xfer += iprot->readListBegin(_etype870, _size867); + this->foreignKeys.resize(_size867); + uint32_t _i871; + for (_i871 = 0; _i871 < _size867; ++_i871) { - xfer += this->foreignKeys[_i863].read(iprot); + xfer += this->foreignKeys[_i871].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 _iter864; - for (_iter864 = this->primaryKeys.begin(); _iter864 != this->primaryKeys.end(); ++_iter864) + std::vector<SQLPrimaryKey> ::const_iterator _iter872; + for (_iter872 = this->primaryKeys.begin(); _iter872 != this->primaryKeys.end(); ++_iter872) { - xfer += (*_iter864).write(oprot); + xfer += (*_iter872).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 _iter865; - for (_iter865 = this->foreignKeys.begin(); _iter865 != this->foreignKeys.end(); ++_iter865) + std::vector<SQLForeignKey> ::const_iterator _iter873; + for (_iter873 = this->foreignKeys.begin(); _iter873 != this->foreignKeys.end(); ++_iter873) { - xfer += (*_iter865).write(oprot); + xfer += (*_iter873).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 _iter866; - for (_iter866 = (*(this->primaryKeys)).begin(); _iter866 != (*(this->primaryKeys)).end(); ++_iter866) + std::vector<SQLPrimaryKey> ::const_iterator _iter874; + for (_iter874 = (*(this->primaryKeys)).begin(); _iter874 != (*(this->primaryKeys)).end(); ++_iter874) { - xfer += (*_iter866).write(oprot); + xfer += (*_iter874).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 _iter867; - for (_iter867 = (*(this->foreignKeys)).begin(); _iter867 != (*(this->foreignKeys)).end(); ++_iter867) + std::vector<SQLForeignKey> ::const_iterator _iter875; + for (_iter875 = (*(this->foreignKeys)).begin(); _iter875 != (*(this->foreignKeys)).end(); ++_iter875) { - xfer += (*_iter867).write(oprot); + xfer += (*_iter875).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6055,14 +6055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size868; - ::apache::thrift::protocol::TType _etype871; - xfer += iprot->readListBegin(_etype871, _size868); - this->success.resize(_size868); - uint32_t _i872; - for (_i872 = 0; _i872 < _size868; ++_i872) + uint32_t _size876; + ::apache::thrift::protocol::TType _etype879; + xfer += iprot->readListBegin(_etype879, _size876); + this->success.resize(_size876); + uint32_t _i880; + for (_i880 = 0; _i880 < _size876; ++_i880) { - xfer += iprot->readString(this->success[_i872]); + xfer += iprot->readString(this->success[_i880]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6101,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 _iter873; - for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) + std::vector<std::string> ::const_iterator _iter881; + for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) { - xfer += oprot->writeString((*_iter873)); + xfer += oprot->writeString((*_iter881)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - (*(this->success)).resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + uint32_t _size882; + ::apache::thrift::protocol::TType _etype885; + xfer += iprot->readListBegin(_etype885, _size882); + (*(this->success)).resize(_size882); + uint32_t _i886; + for (_i886 = 0; _i886 < _size882; ++_i886) { - xfer += iprot->readString((*(this->success))[_i878]); + xfer += iprot->readString((*(this->success))[_i886]); } xfer += iprot->readListEnd(); } @@ -6231,14 +6231,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 _size879; - ::apache::thrift::protocol::TType _etype882; - xfer += iprot->readListBegin(_etype882, _size879); - this->tbl_types.resize(_size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->tbl_types.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += iprot->readString(this->tbl_types[_i883]); + xfer += iprot->readString(this->tbl_types[_i891]); } xfer += iprot->readListEnd(); } @@ -6275,10 +6275,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 _iter884; - for (_iter884 = this->tbl_types.begin(); _iter884 != this->tbl_types.end(); ++_iter884) + std::vector<std::string> ::const_iterator _iter892; + for (_iter892 = this->tbl_types.begin(); _iter892 != this->tbl_types.end(); ++_iter892) { - xfer += oprot->writeString((*_iter884)); + xfer += oprot->writeString((*_iter892)); } xfer += oprot->writeListEnd(); } @@ -6310,10 +6310,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 _iter885; - for (_iter885 = (*(this->tbl_types)).begin(); _iter885 != (*(this->tbl_types)).end(); ++_iter885) + std::vector<std::string> ::const_iterator _iter893; + for (_iter893 = (*(this->tbl_types)).begin(); _iter893 != (*(this->tbl_types)).end(); ++_iter893) { - xfer += oprot->writeString((*_iter885)); + xfer += oprot->writeString((*_iter893)); } xfer += oprot->writeListEnd(); } @@ -6354,14 +6354,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size886; - ::apache::thrift::protocol::TType _etype889; - xfer += iprot->readListBegin(_etype889, _size886); - this->success.resize(_size886); - uint32_t _i890; - for (_i890 = 0; _i890 < _size886; ++_i890) + uint32_t _size894; + ::apache::thrift::protocol::TType _etype897; + xfer += iprot->readListBegin(_etype897, _size894); + this->success.resize(_size894); + uint32_t _i898; + for (_i898 = 0; _i898 < _size894; ++_i898) { - xfer += this->success[_i890].read(iprot); + xfer += this->success[_i898].read(iprot); } xfer += iprot->readListEnd(); } @@ -6400,10 +6400,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 _iter891; - for (_iter891 = this->success.begin(); _iter891 != this->success.end(); ++_iter891) + std::vector<TableMeta> ::const_iterator _iter899; + for (_iter899 = this->success.begin(); _iter899 != this->success.end(); ++_iter899) { - xfer += (*_iter891).write(oprot); + xfer += (*_iter899).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6448,14 +6448,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size892; - ::apache::thrift::protocol::TType _etype895; - xfer += iprot->readListBegin(_etype895, _size892); - (*(this->success)).resize(_size892); - uint32_t _i896; - for (_i896 = 0; _i896 < _size892; ++_i896) + 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 += (*(this->success))[_i896].read(iprot); + xfer += (*(this->success))[_i904].read(iprot); } xfer += iprot->readListEnd(); } @@ -6593,14 +6593,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size897; - ::apache::thrift::protocol::TType _etype900; - xfer += iprot->readListBegin(_etype900, _size897); - this->success.resize(_size897); - uint32_t _i901; - for (_i901 = 0; _i901 < _size897; ++_i901) + uint32_t _size905; + ::apache::thrift::protocol::TType _etype908; + xfer += iprot->readListBegin(_etype908, _size905); + this->success.resize(_size905); + uint32_t _i909; + for (_i909 = 0; _i909 < _size905; ++_i909) { - xfer += iprot->readString(this->success[_i901]); + xfer += iprot->readString(this->success[_i909]); } xfer += iprot->readListEnd(); } @@ -6639,10 +6639,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 _iter902; - for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) + std::vector<std::string> ::const_iterator _iter910; + for (_iter910 = this->success.begin(); _iter910 != this->success.end(); ++_iter910) { - xfer += oprot->writeString((*_iter902)); + xfer += oprot->writeString((*_iter910)); } xfer += oprot->writeListEnd(); } @@ -6687,14 +6687,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size903; - ::apache::thrift::protocol::TType _etype906; - xfer += iprot->readListBegin(_etype906, _size903); - (*(this->success)).resize(_size903); - uint32_t _i907; - for (_i907 = 0; _i907 < _size903; ++_i907) + uint32_t _size911; + ::apache::thrift::protocol::TType _etype914; + xfer += iprot->readListBegin(_etype914, _size911); + (*(this->success)).resize(_size911); + uint32_t _i915; + for (_i915 = 0; _i915 < _size911; ++_i915) { - xfer += iprot->readString((*(this->success))[_i907]); + xfer += iprot->readString((*(this->success))[_i915]); } xfer += iprot->readListEnd(); } @@ -7004,14 +7004,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 _size908; - ::apache::thrift::protocol::TType _etype911; - xfer += iprot->readListBegin(_etype911, _size908); - this->tbl_names.resize(_size908); - uint32_t _i912; - for (_i912 = 0; _i912 < _size908; ++_i912) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->tbl_names.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += iprot->readString(this->tbl_names[_i912]); + xfer += iprot->readString(this->tbl_names[_i920]); } xfer += iprot->readListEnd(); } @@ -7044,10 +7044,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 _iter913; - for (_iter913 = this->tbl_names.begin(); _iter913 != this->tbl_names.end(); ++_iter913) + std::vector<std::string> ::const_iterator _iter921; + for (_iter921 = this->tbl_names.begin(); _iter921 != this->tbl_names.end(); ++_iter921) { - xfer += oprot->writeString((*_iter913)); + xfer += oprot->writeString((*_iter921)); } xfer += oprot->writeListEnd(); } @@ -7075,10 +7075,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 _iter914; - for (_iter914 = (*(this->tbl_names)).begin(); _iter914 != (*(this->tbl_names)).end(); ++_iter914) + std::vector<std::string> ::const_iterator _iter922; + for (_iter922 = (*(this->tbl_names)).begin(); _iter922 != (*(this->tbl_names)).end(); ++_iter922) { - xfer += oprot->writeString((*_iter914)); + xfer += oprot->writeString((*_iter922)); } xfer += oprot->writeListEnd(); } @@ -7119,14 +7119,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 _size915; - ::apache::thrift::protocol::TType _etype918; - xfer += iprot->readListBegin(_etype918, _size915); - this->success.resize(_size915); - uint32_t _i919; - for (_i919 = 0; _i919 < _size915; ++_i919) + uint32_t _size923; + ::apache::thrift::protocol::TType _etype926; + xfer += iprot->readListBegin(_etype926, _size923); + this->success.resize(_size923); + uint32_t _i927; + for (_i927 = 0; _i927 < _size923; ++_i927) { - xfer += this->success[_i919].read(iprot); + xfer += this->success[_i927].read(iprot); } xfer += iprot->readListEnd(); } @@ -7181,10 +7181,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 _iter920; - for (_iter920 = this->success.begin(); _iter920 != this->success.end(); ++_iter920) + std::vector<Table> ::const_iterator _iter928; + for (_iter928 = this->success.begin(); _iter928 != this->success.end(); ++_iter928) { - xfer += (*_iter920).write(oprot); + xfer += (*_iter928).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7237,14 +7237,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 _size921; - ::apache::thrift::protocol::TType _etype924; - xfer += iprot->readListBegin(_etype924, _size921); - (*(this->success)).resize(_size921); - uint32_t _i925; - for (_i925 = 0; _i925 < _size921; ++_i925) + uint32_t _size929; + ::apache::thrift::protocol::TType _etype932; + xfer += iprot->readListBegin(_etype932, _size929); + (*(this->success)).resize(_size929); + uint32_t _i933; + for (_i933 = 0; _i933 < _size929; ++_i933) { - xfer += (*(this->success))[_i925].read(iprot); + xfer += (*(this->success))[_i933].read(iprot); } xfer += iprot->readListEnd(); } @@ -7430,14 +7430,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 _size926; - ::apache::thrift::protocol::TType _etype929; - xfer += iprot->readListBegin(_etype929, _size926); - this->success.resize(_size926); - uint32_t _i930; - for (_i930 = 0; _i930 < _size926; ++_i930) + uint32_t _size934; + ::apache::thrift::protocol::TType _etype937; + xfer += iprot->readListBegin(_etype937, _size934); + this->success.resize(_size934); + uint32_t _i938; + for (_i938 = 0; _i938 < _size934; ++_i938) { - xfer += iprot->readString(this->success[_i930]); + xfer += iprot->readString(this->success[_i938]); } xfer += iprot->readListEnd(); } @@ -7492,10 +7492,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 _iter931; - for (_iter931 = this->success.begin(); _iter931 != this->success.end(); ++_iter931) + std::vector<std::string> ::const_iterator _iter939; + for (_iter939 = this->success.begin(); _iter939 != this->success.end(); ++_iter939) { - xfer += oprot->writeString((*_iter931)); + xfer += oprot->writeString((*_iter939)); } xfer += oprot->writeListEnd(); } @@ -7548,14 +7548,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 _size932; - ::apache::thrift::protocol::TType _etype935; - xfer += iprot->readListBegin(_etype935, _size932); - (*(this->success)).resize(_size932); - uint32_t _i936; - for (_i936 = 0; _i936 < _size932; ++_i936) + uint32_t _size940; + ::apache::thrift::protocol::TType _etype943; + xfer += iprot->readListBegin(_etype943, _size940); + (*(this->success)).resize(_size940); + uint32_t _i944; + for (_i944 = 0; _i944 < _size940; ++_i944) { - xfer += iprot->readString((*(this->success))[_i936]); + xfer += iprot->readString((*(this->success))[_i944]); } xfer += iprot->readListEnd(); } @@ -8889,14 +8889,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size937; - ::apache::thrift::protocol::TType _etype940; - xfer += iprot->readListBegin(_etype940, _size937); - this->new_parts.resize(_size937); - uint32_t _i941; - for (_i941 = 0; _i941 < _size937; ++_i941) + uint32_t _size945; + ::apache::thrift::protocol::TType _etype948; + xfer += iprot->readListBegin(_etype948, _size945); + this->new_parts.resize(_size945); + uint32_t _i949; + for (_i949 = 0; _i949 < _size945; ++_i949) { - xfer += this->new_parts[_i941].read(iprot); + xfer += this->new_parts[_i949].read(iprot); } xfer += iprot->readListEnd(); } @@ -8925,10 +8925,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 _iter942; - for (_iter942 = this->new_parts.begin(); _iter942 != this->new_parts.end(); ++_iter942) + std::vector<Partition> ::const_iterator _iter950; + for (_iter950 = this->new_parts.begin(); _iter950 != this->new_parts.end(); ++_iter950) { - xfer += (*_iter942).write(oprot); + xfer += (*_iter950).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8952,10 +8952,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 _iter943; - for (_iter943 = (*(this->new_parts)).begin(); _iter943 != (*(this->new_parts)).end(); ++_iter943) + std::vector<Partition> ::const_iterator _iter951; + for (_iter951 = (*(this->new_parts)).begin(); _iter951 != (*(this->new_parts)).end(); ++_iter951) { - xfer += (*_iter943).write(oprot); + xfer += (*_iter951).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9164,14 +9164,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 _size944; - ::apache::thrift::protocol::TType _etype947; - xfer += iprot->readListBegin(_etype947, _size944); - this->new_parts.resize(_size944); - uint32_t _i948; - for (_i948 = 0; _i948 < _size944; ++_i948) + uint32_t _size952; + ::apache::thrift::protocol::TType _etype955; + xfer += iprot->readListBegin(_etype955, _size952); + this->new_parts.resize(_size952); + uint32_t _i956; + for (_i956 = 0; _i956 < _size952; ++_i956) { - xfer += this->new_parts[_i948].read(iprot); + xfer += this->new_parts[_i956].read(iprot); } xfer += iprot->readListEnd(); } @@ -9200,10 +9200,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 _iter949; - for (_iter949 = this->new_parts.begin(); _iter949 != this->new_parts.end(); ++_iter949) + std::vector<PartitionSpec> ::const_iterator _iter957; + for (_iter957 = this->new_parts.begin(); _iter957 != this->new_parts.end(); ++_iter957) { - xfer += (*_iter949).write(oprot); + xfer += (*_iter957).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9227,10 +9227,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 _iter950; - for (_iter950 = (*(this->new_parts)).begin(); _iter950 != (*(this->new_parts)).end(); ++_iter950) + std::vector<PartitionSpec> ::const_iterator _iter958; + for (_iter958 = (*(this->new_parts)).begin(); _iter958 != (*(this->new_parts)).end(); ++_iter958) { - xfer += (*_iter950).write(oprot); + xfer += (*_iter958).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9455,14 +9455,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size951; - ::apache::thrift::protocol::TType _etype954; - xfer += iprot->readListBegin(_etype954, _size951); - this->part_vals.resize(_size951); - uint32_t _i955; - for (_i955 = 0; _i955 < _size951; ++_i955) + uint32_t _size959; + ::apache::thrift::protocol::TType _etype962; + xfer += iprot->readListBegin(_etype962, _size959); + this->part_vals.resize(_size959); + uint32_t _i963; + for (_i963 = 0; _i963 < _size959; ++_i963) { - xfer += iprot->readString(this->part_vals[_i955]); + xfer += iprot->readString(this->part_vals[_i963]); } xfer += iprot->readListEnd(); } @@ -9499,10 +9499,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 _iter956; - for (_iter956 = this->part_vals.begin(); _iter956 != this->part_vals.end(); ++_iter956) + std::vector<std::string> ::const_iterator _iter964; + for (_iter964 = this->part_vals.begin(); _iter964 != this->part_vals.end(); ++_iter964) { - xfer += oprot->writeString((*_iter956)); + xfer += oprot->writeString((*_iter964)); } xfer += oprot->writeListEnd(); } @@ -9534,10 +9534,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 _iter957; - for (_iter957 = (*(this->part_vals)).begin(); _iter957 != (*(this->part_vals)).end(); ++_iter957) + std::vector<std::string> ::const_iterator _iter965; + for (_iter965 = (*(this->part_vals)).begin(); _iter965 != (*(this->part_vals)).end(); ++_iter965) { - xfer += oprot->writeString((*_iter957)); + xfer += oprot->writeString((*_iter965)); } xfer += oprot->writeListEnd(); } @@ -10009,14 +10009,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size958; - ::apache::thrift::protocol::TType _etype961; - xfer += iprot->readListBegin(_etype961, _size958); - this->part_vals.resize(_size958); - uint32_t _i962; - for (_i962 = 0; _i962 < _size958; ++_i962) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->part_vals.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += iprot->readString(this->part_vals[_i962]); + xfer += iprot->readString(this->part_vals[_i970]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10061,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 _iter963; - for (_iter963 = this->part_vals.begin(); _iter963 != this->part_vals.end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter971; + for (_iter971 = this->part_vals.begin(); _iter971 != this->part_vals.end(); ++_iter971) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -10100,10 +10100,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 _iter964; - for (_iter964 = (*(this->part_vals)).begin(); _iter964 != (*(this->part_vals)).end(); ++_iter964) + std::vector<std::string> ::const_iterator _iter972; + for (_iter972 = (*(this->part_vals)).begin(); _iter972 != (*(this->part_vals)).end(); ++_iter972) { - xfer += oprot->writeString((*_iter964)); + xfer += oprot->writeString((*_iter972)); } xfer += oprot->writeListEnd(); } @@ -10906,14 +10906,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size965; - ::apache::thrift::protocol::TType _etype968; - xfer += iprot->readListBegin(_etype968, _size965); - this->part_vals.resize(_size965); - uint32_t _i969; - for (_i969 = 0; _i969 < _size965; ++_i969) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + this->part_vals.resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += iprot->readString(this->part_vals[_i969]); + xfer += iprot->readString(this->part_vals[_i977]); } xfer += iprot->readListEnd(); } @@ -10958,10 +10958,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 _iter970; - for (_iter970 = this->part_vals.begin(); _iter970 != this->part_vals.end(); ++_iter970) + std::vector<std::string> ::const_iterator _iter978; + for (_iter978 = this->part_vals.begin(); _iter978 != this->part_vals.end(); ++_iter978) { - xfer += oprot->writeString((*_iter970)); + xfer += oprot->writeString((*_iter978)); } xfer += oprot->writeListEnd(); } @@ -10997,10 +10997,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 _iter971; - for (_iter971 = (*(this->part_vals)).begin(); _iter971 != (*(this->part_vals)).end(); ++_iter971) + std::vector<std::string> ::const_iterator _iter979; + for (_iter979 = (*(this->part_vals)).begin(); _iter979 != (*(this->part_vals)).end(); ++_iter979) { - xfer += oprot->writeString((*_iter971)); + xfer += oprot->writeString((*_iter979)); } xfer += oprot->writeListEnd(); } @@ -11209,14 +11209,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size972; - ::apache::thrift::protocol::TType _etype975; - xfer += iprot->readListBegin(_etype975, _size972); - this->part_vals.resize(_size972); - uint32_t _i976; - for (_i976 = 0; _i976 < _size972; ++_i976) + uint32_t _size980; + ::apache::thrift::protocol::TType _etype983; + xfer += iprot->readListBegin(_etype983, _size980); + this->part_vals.resize(_size980); + uint32_t _i984; + for (_i984 = 0; _i984 < _size980; ++_i984) { - xfer += iprot->readString(this->part_vals[_i976]); + xfer += iprot->readString(this->part_vals[_i984]); } xfer += iprot->readListEnd(); } @@ -11269,10 +11269,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 _iter977; - for (_iter977 = this->part_vals.begin(); _iter977 != this->part_vals.end(); ++_iter977) + std::vector<std::string> ::const_iterator _iter985; + for (_iter985 = this->part_vals.begin(); _iter985 != this->part_vals.end(); ++_iter985) { - xfer += oprot->writeString((*_iter977)); + xfer += oprot->writeString((*_iter985)); } xfer += oprot->writeListEnd(); } @@ -11312,10 +11312,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 _iter978; - for (_iter978 = (*(this->part_vals)).begin(); _iter978 != (*(this->part_vals)).end(); ++_iter978) + std::vector<std::string> ::const_iterator _iter986; + for (_iter986 = (*(this->part_vals)).begin(); _iter986 != (*(this->part_vals)).end(); ++_iter986) { - xfer += oprot->writeString((*_iter978)); + xfer += oprot->writeString((*_iter986)); } xfer += oprot->writeListEnd(); } @@ -12321,14 +12321,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size979; - ::apache::thrift::protocol::TType _etype982; - xfer += iprot->readListBegin(_etype982, _size979); - this->part_vals.resize(_size979); - uint32_t _i983; - for (_i983 = 0; _i983 < _size979; ++_i983) + uint32_t _size987; + ::apache::thrift::protocol::TType _etype990; + xfer += iprot->readListBegin(_etype990, _size987); + this->part_vals.resize(_size987); + uint32_t _i991; + for (_i991 = 0; _i991 < _size987; ++_i991) { - xfer += iprot->readString(this->part_vals[_i983]); + xfer += iprot->readString(this->part_vals[_i991]); } xfer += iprot->readListEnd(); } @@ -12365,10 +12365,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 _iter984; - for (_iter984 = this->part_vals.begin(); _iter984 != this->part_vals.end(); ++_iter984) + std::vector<std::string> ::const_iterator _iter992; + for (_iter992 = this->part_vals.begin(); _iter992 != this->part_vals.end(); ++_iter992) { - xfer += oprot->writeString((*_iter984)); + xfer += oprot->writeString((*_iter992)); } xfer += oprot->writeListEnd(); } @@ -12400,10 +12400,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 _iter985; - for (_iter985 = (*(this->part_vals)).begin(); _iter985 != (*(this->part_vals)).end(); ++_iter985) + std::vector<std::string> ::const_iterator _iter993; + for (_iter993 = (*(this->part_vals)).begin(); _iter993 != (*(this->part_vals)).end(); ++_iter993) { - xfer += oprot->writeString((*_iter985)); + xfer += oprot->writeString((*_iter993)); } xfer += oprot->writeListEnd(); } @@ -12592,17 +12592,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size986; - ::apache::thrift::protocol::TType _ktype987; - ::apache::thrift::protocol::TType _vtype988; - xfer += iprot->readMapBegin(_ktype987, _vtype988, _size986); - uint32_t _i990; - for (_i990 = 0; _i990 < _size986; ++_i990) + uint32_t _size994; + ::apache::thrift::protocol::TType _ktype995; + ::apache::thrift::protocol::TType _vtype996; + xfer += iprot->readMapBegin(_ktype995, _vtype996, _size994); + uint32_t _i998; + for (_i998 = 0; _i998 < _size994; ++_i998) { - std::string _key991; - xfer += iprot->readString(_key991); - std::string& _val992 = this->partitionSpecs[_key991]; - xfer += iprot->readString(_val992); + std::string _key999; + xfer += iprot->readString(_key999); + std::string& _val1000 = this->partitionSpecs[_key999]; + xfer += iprot->readString(_val1000); } xfer += iprot->readMapEnd(); } @@ -12663,11 +12663,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 _iter993; - for (_iter993 = this->partitionSpecs.begin(); _iter993 != this->partitionSpecs.end(); ++_iter993) + std::map<std::string, std::string> ::const_iterator _iter1001; + for (_iter1001 = this->partitionSpecs.begin(); _iter1001 != this->partitionSpecs.end(); ++_iter1001) { - xfer += oprot->writeString(_iter993->first); - xfer += oprot->writeString(_iter993->second); + xfer += oprot->writeString(_iter1001->first); + xfer += oprot->writeString(_iter1001->second); } xfer += oprot->writeMapEnd(); } @@ -12707,11 +12707,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 _iter994; - for (_iter994 = (*(this->partitionSpecs)).begin(); _iter994 != (*(this->partitionSpecs)).end(); ++_iter994) + std::map<std::string, std::string> ::const_iterator _iter1002; + for (_iter1002 = (*(this->partitionSpecs)).begin(); _iter1002 != (*(this->partitionSpecs)).end(); ++_iter1002) { - xfer += oprot->writeString(_iter994->first); - xfer += oprot->writeString(_iter994->second); + xfer += oprot->writeString(_iter1002->first); + xfer += oprot->writeString(_iter1002->second); } xfer += oprot->writeMapEnd(); } @@ -12956,17 +12956,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size995; - ::apache::thrift::protocol::TType _ktype996; - ::apache::thrift::protocol::TType _vtype997; - xfer += iprot->readMapBegin(_ktype996, _vtype997, _size995); - uint32_t _i999; - for (_i999 = 0; _i999 < _size995; ++_i999) + uint32_t _size1003; + ::apache::thrift::protocol::TType _ktype1004; + ::apache::thrift::protocol::TType _vtype1005; + xfer += iprot->readMapBegin(_ktype1004, _vtype1005, _size1003); + uint32_t _i1007; + for (_i1007 = 0; _i1007 < _size1003; ++_i1007) { - std::string _key1000; - xfer += iprot->readString(_key1000); - std::string& _val1001 = this->partitionSpecs[_key1000]; - xfer += iprot->readString(_val1001); + std::string _key1008; + xfer += iprot->readString(_key1008); + std::string& _val1009 = this->partitionSpecs[_key1008]; + xfer += iprot->readString(_val1009); } xfer += iprot->readMapEnd(); } @@ -13027,11 +13027,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 _iter1002; - for (_iter1002 = this->partitionSpecs.begin(); _iter1002 != this->partitionSpecs.end(); ++_iter1002) + std::map<std::string, std::string> ::const_iterator _iter1010; + for (_iter1010 = this->partitionSpecs.begin(); _iter1010 != this->partitionSpecs.end(); ++_iter1010) { - xfer += oprot->writeString(_iter1002->first); - xfer += oprot->writeString(_iter1002->second); + xfer += oprot->writeString(_iter1010->first); + xfer += oprot->writeString(_iter1010->second); } xfer += oprot->writeMapEnd(); } @@ -13071,11 +13071,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 _iter1003; - for (_iter1003 = (*(this->partitionSpecs)).begin(); _iter1003 != (*(this->partitionSpecs)).end(); ++_iter1003) + std::map<std::string, std::string> ::const_iterator _iter1011; + for (_iter1011 = (*(this->partitionSpecs)).begin(); _iter1011 != (*(this->partitionSpecs)).end(); ++_iter1011) { - xfer += oprot->writeString(_iter1003->first); - xfer += oprot->writeString(_iter1003->second); + xfer += oprot->writeString(_iter1011->first); + xfer += oprot->writeString(_iter1011->second); } xfer += oprot->writeMapEnd(); } @@ -13132,14 +13132,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1004; - ::apache::thrift::protocol::TType _etype1007; - xfer += iprot->readListBegin(_etype1007, _size1004); - this->success.resize(_size1004); - uint32_t _i1008; - for (_i1008 = 0; _i1008 < _size1004; ++_i1008) + uint32_t _size1012; + ::apache::thrift::protocol::TType _etype1015; + xfer += iprot->readListBegin(_etype1015, _size1012); + this->success.resize(_size1012); + uint32_t _i1016; + for (_i1016 = 0; _i1016 < _size1012; ++_i1016) { - xfer += this->success[_i1008].read(iprot); + xfer += this->success[_i1016].read(iprot); } xfer += iprot->readListEnd(); } @@ -13202,10 +13202,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 _iter1009; - for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) + std::vector<Partition> ::const_iterator _iter1017; + for (_iter1017 = this->success.begin(); _iter1017 != this->success.end(); ++_iter1017) { - xfer += (*_iter1009).write(oprot); + xfer += (*_iter1017).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13262,14 +13262,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1010; - ::apache::thrift::protocol::TType _etype1013; - xfer += iprot->readListBegin(_etype1013, _size1010); - (*(this->success)).resize(_size1010); - uint32_t _i1014; - for (_i1014 = 0; _i1014 < _size1010; ++_i1014) + uint32_t _size1018; + ::apache::thrift::protocol::TType _etype1021; + xfer += iprot->readListBegin(_etype1021, _size1018); + (*(this->success)).resize(_size1018); + uint32_t _i1022; + for (_i1022 = 0; _i1022 < _size1018; ++_i1022) { - xfer += (*(this->success))[_i1014].read(iprot); + xfer += (*(this->success))[_i1022].read(iprot); } xfer += iprot->readListEnd(); } @@ -13368,14 +13368,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 _size1015; - ::apache::thrift::protocol::TType _etype1018; - xfer += iprot->readListBegin(_etype1018, _size1015); - this->part_vals.resize(_size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1023; + ::apache::thrift::protocol::TType _etype1026; + xfer += iprot->readListBegin(_etype1026, _size1023); + this->part_vals.resize(_size1023); + uint32_t _i1027; + for (_i1027 = 0; _i1027 < _size1023; ++_i1027) { - xfer += iprot->readString(this->part_vals[_i1019]); + xfer += iprot->readString(this->part_vals[_i1027]); } xfer += iprot->readListEnd(); } @@ -13396,14 +13396,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 _size1020; - ::apache::thrift::protocol::TType _etype1023; - xfer += iprot->readListBegin(_etype1023, _size1020); - this->group_names.resize(_size1020); - uint32_t _i1024; - for (_i1024 = 0; _i1024 < _size1020; ++_i1024) + uint32_t _size1028; + ::apache::thrift::protocol::TType _etype1031; + xfer += iprot->readListBegin(_etype1031, _size1028); + this->group_names.resize(_size1028); + uint32_t _i1032; + for (_i1032 = 0; _i1032 < _size1028; ++_i1032) { - xfer += iprot->readString(this->group_names[_i1024]); + xfer += iprot->readString(this->group_names[_i1032]); } xfer += iprot->readListEnd(); } @@ -13440,10 +13440,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 _iter1025; - for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) + std::vector<std::string> ::const_iterator _iter1033; + for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) { - xfer += oprot->writeString((*_iter1025)); + xfer += oprot->writeString((*_iter1033)); } xfer += oprot->writeListEnd(); } @@ -13456,10 +13456,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 _iter1026; - for (_iter1026 = this->group_names.begin(); _iter1026 != this->group_names.end(); ++_iter1026) + std::vector<std::string> ::const_iterator _iter1034; + for (_iter1034 = this->group_names.begin(); _iter1034 != this->group_names.end(); ++_iter1034) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1034)); } xfer += oprot->writeListEnd(); } @@ -13491,10 +13491,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 _iter1027; - for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) + std::vector<std::string> ::const_iterator _iter1035; + for (_iter1035 = (*(this->part_vals)).begin(); _iter1035 != (*(this->part_vals)).end(); ++_iter1035) { - xfer += oprot->writeString((*_iter1027)); + xfer += oprot->writeString((*_iter1035)); } xfer += oprot->writeListEnd(); } @@ -13507,10 +13507,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 _iter1028; - for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028) + std::vector<std::string> ::const_iterator _iter1036; + for (_iter1036 = (*(this->group_names)).begin(); _iter1036 != (*(this->group_names)).end(); ++_iter1036) { - xfer += oprot->writeString((*_iter1028)); + xfer += oprot->writeString((*_iter1036)); } xfer += oprot->writeListEnd(); } @@ -14069,14 +14069,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1029; - ::apache::thrift::protocol::TType _etype1032; - xfer += iprot->readListBegin(_etype1032, _size1029); - this->success.resize(_size1029); - uint32_t _i1033; - for (_i1033 = 0; _i1033 < _size1029; ++_i1033) + uint32_t _size1037; + ::apache::thrift::protocol::TType _etype1040; + xfer += iprot->readListBegin(_etype1040, _size1037); + this->success.resize(_size1037); + uint32_t _i1041; + for (_i1041 = 0; _i1041 < _size1037; ++_i1041) { - xfer += this->success[_i1033].read(iprot); + xfer += this->success[_i1041].read(iprot); } xfer += iprot->readListEnd(); } @@ -14123,10 +14123,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 _iter1034; - for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034) + std::vector<Partition> ::const_iterator _iter1042; + for (_iter1042 = this->success.begin(); _iter1042 != this->success.end(); ++_iter1042) { - xfer += (*_iter1034).write(oprot); + xfer += (*_iter1042).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14175,14 +14175,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - (*(this->success)).resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + 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 += (*(this->success))[_i1039].read(iprot); + xfer += (*(this->success))[_i1047].read(iprot); } xfer += iprot->readListEnd(); } @@ -14281,14 +14281,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 _size1040; - ::apache::thrift::protocol::TType _etype1043; - xfer += iprot->readListBegin(_etype1043, _size1040); - this->group_names.resize(_size1040); - uint32_t _i1044; - for (_i1044 = 0; _i1044 < _size1040; ++_i1044) + uint32_t _size1048; + ::apache::thrift::protocol::TType _etype1051; + xfer += iprot->readListBegin(_etype1051, _size1048); + this->group_names.resize(_size1048); + uint32_t _i1052; + for (_i1052 = 0; _i1052 < _size1048; ++_i1052) { - xfer += iprot->readString(this->group_names[_i1044]); + xfer += iprot->readString(this->group_names[_i1052]); } xfer += iprot->readListEnd(); } @@ -14333,10 +14333,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 _iter1045; - for (_iter1045 = this->group_names.begin(); _iter1045 != this->group_names.end(); ++_iter1045) + std::vector<std::string> ::const_iterator _iter1053; + for (_iter1053 = this->group_names.begin(); _iter1053 != this->group_names.end(); ++_iter1053) { - xfer += oprot->writeString((*_iter1045)); + xfer += oprot->writeString((*_iter1053)); } xfer += oprot->writeListEnd(); } @@ -14376,10 +14376,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 _iter1046; - for (_iter1046 = (*(this->group_names)).begin(); _iter1046 != (*(this->group_names)).end(); ++_iter1046) + std::vector<std::string> ::const_iterator _iter1054; + for (_iter1054 = (*(this->group_names)).begin(); _iter1054 != (*(this->group_names)).end(); ++_iter1054) { - xfer += oprot->writeString((*_iter1046)); + xfer += oprot->writeString((*_iter1054)); } xfer += oprot->writeListEnd(); } @@ -14420,14 +14420,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr 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 _size1055; + ::apache::thrift::protocol::TType _etype1058; + xfer += iprot->readListBegin(_etype1058, _size1055); + this->success.resize(_size1055); + uint32_t _i1059; + for (_i1059 = 0; _i1059 < _size1055; ++_i1059) { - xfer += this->success[_i1051].read(iprot); + xfer += this->success[_i1059].read(iprot); } xfer += iprot->readListEnd(); } @@ -14474,10 +14474,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 _iter1052; - for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) + std::vector<Partition> ::const_iterator _iter1060; + for (_iter1060 = this->success.begin(); _iter1060 != this->success.end(); ++_iter1060) { - xfer += (*_iter1052).write(oprot); + xfer += (*_iter1060).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14526,14 +14526,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1053; - ::apache::thrift::protocol::TType _etype1056; - xfer += iprot->readListBegin(_etype1056, _size1053); - (*(this->success)).resize(_size1053); - uint32_t _i1057; - for (_i1057 = 0; _i1057 < _size1053; ++_i1057) + uint32_t _size1061; + ::apache::thrift::protocol::TType _etype1064; + xfer += iprot->readListBegin(_etype1064, _size1061); + (*(this->success)).resize(_size1061); + uint32_t _i1065; + for (_i1065 = 0; _i1065 < _size1061; ++_i1065) { - xfer += (*(this->success))[_i1057].read(iprot); + xfer += (*(this->success))[_i1065].read(iprot); } xfer += iprot->readListEnd(); } @@ -14711,14 +14711,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1058; - ::apache::thrift::protocol::TType _etype1061; - xfer += iprot->readListBegin(_etype1061, _size1058); - this->success.resize(_size1058); - uint32_t _i1062; - for (_i1062 = 0; _i1062 < _size1058; ++_i1062) + uint32_t _size1066; + ::apache::thrift::protocol::TType _etype1069; + xfer += iprot->readListBegin(_etype1069, _size1066); + this->success.resize(_size1066); + uint32_t _i1070; + for (_i1070 = 0; _i1070 < _size1066; ++_i1070) { - xfer += this->success[_i1062].read(iprot); + xfer += this->success[_i1070].read(iprot); } xfer += iprot->readListEnd(); } @@ -14765,10 +14765,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 _iter1063; - for (_iter1063 = this->success.begin(); _iter1063 != this->success.end(); ++_iter1063) + std::vector<PartitionSpec> ::const_iterator _iter1071; + for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) { - xfer += (*_iter1063).write(oprot); + xfer += (*_iter1071).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14817,14 +14817,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1064; - ::apache::thrift::protocol::TType _etype1067; - xfer += iprot->readListBegin(_etype1067, _size1064); - (*(this->success)).resize(_size1064); - uint32_t _i1068; - for (_i1068 = 0; _i1068 < _size1064; ++_i1068) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + (*(this->success)).resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += (*(this->success))[_i1068].read(iprot); + xfer += (*(this->success))[_i1076].read(iprot); } xfer += iprot->readListEnd(); } @@ -15002,14 +15002,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1069; - ::apache::thrift::protocol::TType _etype1072; - xfer += iprot->readListBegin(_etype1072, _size1069); - this->success.resize(_size1069); - uint32_t _i1073; - for (_i1073 = 0; _i1073 < _size1069; ++_i1073) + uint32_t _size1077; + ::apache::thrift::protocol::TType _etype1080; + xfer += iprot->readListBegin(_etype1080, _size1077); + this->success.resize(_size1077); + uint32_t _i1081; + for (_i1081 = 0; _i1081 < _size1077; ++_i1081) { - xfer += iprot->readString(this->success[_i1073]); + xfer += iprot->readString(this->su
<TRUNCATED>
