http://git-wip-us.apache.org/repos/asf/hive/blob/6af51245/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 54d6438..9042cdb 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 _size818; - ::apache::thrift::protocol::TType _etype821; - xfer += iprot->readListBegin(_etype821, _size818); - this->success.resize(_size818); - uint32_t _i822; - for (_i822 = 0; _i822 < _size818; ++_i822) + 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 += iprot->readString(this->success[_i822]); + xfer += iprot->readString(this->success[_i821]); } 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 _iter823; - for (_iter823 = this->success.begin(); _iter823 != this->success.end(); ++_iter823) + std::vector<std::string> ::const_iterator _iter822; + for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter822)); } 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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - (*(this->success)).resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + uint32_t _size823; + ::apache::thrift::protocol::TType _etype826; + xfer += iprot->readListBegin(_etype826, _size823); + (*(this->success)).resize(_size823); + uint32_t _i827; + for (_i827 = 0; _i827 < _size823; ++_i827) { - xfer += iprot->readString((*(this->success))[_i828]); + xfer += iprot->readString((*(this->success))[_i827]); } 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 _size829; - ::apache::thrift::protocol::TType _etype832; - xfer += iprot->readListBegin(_etype832, _size829); - this->success.resize(_size829); - uint32_t _i833; - for (_i833 = 0; _i833 < _size829; ++_i833) + uint32_t _size828; + ::apache::thrift::protocol::TType _etype831; + xfer += iprot->readListBegin(_etype831, _size828); + this->success.resize(_size828); + uint32_t _i832; + for (_i832 = 0; _i832 < _size828; ++_i832) { - xfer += iprot->readString(this->success[_i833]); + xfer += iprot->readString(this->success[_i832]); } 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 _iter834; - for (_iter834 = this->success.begin(); _iter834 != this->success.end(); ++_iter834) + std::vector<std::string> ::const_iterator _iter833; + for (_iter833 = this->success.begin(); _iter833 != this->success.end(); ++_iter833) { - xfer += oprot->writeString((*_iter834)); + xfer += oprot->writeString((*_iter833)); } 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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - (*(this->success)).resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + uint32_t _size834; + ::apache::thrift::protocol::TType _etype837; + xfer += iprot->readListBegin(_etype837, _size834); + (*(this->success)).resize(_size834); + uint32_t _i838; + for (_i838 = 0; _i838 < _size834; ++_i838) { - xfer += iprot->readString((*(this->success))[_i839]); + xfer += iprot->readString((*(this->success))[_i838]); } xfer += iprot->readListEnd(); } @@ -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 _size840; - ::apache::thrift::protocol::TType _ktype841; - ::apache::thrift::protocol::TType _vtype842; - xfer += iprot->readMapBegin(_ktype841, _vtype842, _size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size839; + ::apache::thrift::protocol::TType _ktype840; + ::apache::thrift::protocol::TType _vtype841; + xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839); + uint32_t _i843; + for (_i843 = 0; _i843 < _size839; ++_i843) { - std::string _key845; - xfer += iprot->readString(_key845); - Type& _val846 = this->success[_key845]; - xfer += _val846.read(iprot); + std::string _key844; + xfer += iprot->readString(_key844); + Type& _val845 = this->success[_key844]; + xfer += _val845.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 _iter847; - for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847) + std::map<std::string, Type> ::const_iterator _iter846; + for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) { - xfer += oprot->writeString(_iter847->first); - xfer += _iter847->second.write(oprot); + xfer += oprot->writeString(_iter846->first); + xfer += _iter846->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 _size848; - ::apache::thrift::protocol::TType _ktype849; - ::apache::thrift::protocol::TType _vtype850; - xfer += iprot->readMapBegin(_ktype849, _vtype850, _size848); - uint32_t _i852; - for (_i852 = 0; _i852 < _size848; ++_i852) + uint32_t _size847; + ::apache::thrift::protocol::TType _ktype848; + ::apache::thrift::protocol::TType _vtype849; + xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); + uint32_t _i851; + for (_i851 = 0; _i851 < _size847; ++_i851) { - std::string _key853; - xfer += iprot->readString(_key853); - Type& _val854 = (*(this->success))[_key853]; - xfer += _val854.read(iprot); + std::string _key852; + xfer += iprot->readString(_key852); + Type& _val853 = (*(this->success))[_key852]; + xfer += _val853.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 _size855; - ::apache::thrift::protocol::TType _etype858; - xfer += iprot->readListBegin(_etype858, _size855); - this->success.resize(_size855); - uint32_t _i859; - for (_i859 = 0; _i859 < _size855; ++_i859) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->success.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += this->success[_i859].read(iprot); + xfer += this->success[_i858].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 _iter860; - for (_iter860 = this->success.begin(); _iter860 != this->success.end(); ++_iter860) + std::vector<FieldSchema> ::const_iterator _iter859; + for (_iter859 = this->success.begin(); _iter859 != this->success.end(); ++_iter859) { - xfer += (*_iter860).write(oprot); + xfer += (*_iter859).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 _size861; - ::apache::thrift::protocol::TType _etype864; - xfer += iprot->readListBegin(_etype864, _size861); - (*(this->success)).resize(_size861); - uint32_t _i865; - for (_i865 = 0; _i865 < _size861; ++_i865) + 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))[_i865].read(iprot); + xfer += (*(this->success))[_i864].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 _size866; - ::apache::thrift::protocol::TType _etype869; - xfer += iprot->readListBegin(_etype869, _size866); - this->success.resize(_size866); - uint32_t _i870; - for (_i870 = 0; _i870 < _size866; ++_i870) + uint32_t _size865; + ::apache::thrift::protocol::TType _etype868; + xfer += iprot->readListBegin(_etype868, _size865); + this->success.resize(_size865); + uint32_t _i869; + for (_i869 = 0; _i869 < _size865; ++_i869) { - xfer += this->success[_i870].read(iprot); + xfer += this->success[_i869].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 _iter871; - for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) + std::vector<FieldSchema> ::const_iterator _iter870; + for (_iter870 = this->success.begin(); _iter870 != this->success.end(); ++_iter870) { - xfer += (*_iter871).write(oprot); + xfer += (*_iter870).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 _size872; - ::apache::thrift::protocol::TType _etype875; - xfer += iprot->readListBegin(_etype875, _size872); - (*(this->success)).resize(_size872); - uint32_t _i876; - for (_i876 = 0; _i876 < _size872; ++_i876) + 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 += (*(this->success))[_i876].read(iprot); + xfer += (*(this->success))[_i875].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 _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - this->success.resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + 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 += this->success[_i881].read(iprot); + xfer += this->success[_i880].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 _iter882; - for (_iter882 = this->success.begin(); _iter882 != this->success.end(); ++_iter882) + std::vector<FieldSchema> ::const_iterator _iter881; + for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) { - xfer += (*_iter882).write(oprot); + xfer += (*_iter881).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 _size883; - ::apache::thrift::protocol::TType _etype886; - xfer += iprot->readListBegin(_etype886, _size883); - (*(this->success)).resize(_size883); - uint32_t _i887; - for (_i887 = 0; _i887 < _size883; ++_i887) + 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 += (*(this->success))[_i887].read(iprot); + xfer += (*(this->success))[_i886].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 _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->success.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->success.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += this->success[_i892].read(iprot); + xfer += this->success[_i891].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 _iter893; - for (_iter893 = this->success.begin(); _iter893 != this->success.end(); ++_iter893) + std::vector<FieldSchema> ::const_iterator _iter892; + for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) { - xfer += (*_iter893).write(oprot); + xfer += (*_iter892).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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - (*(this->success)).resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + 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) { - xfer += (*(this->success))[_i898].read(iprot); + xfer += (*(this->success))[_i897].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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->primaryKeys.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->primaryKeys.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += this->primaryKeys[_i903].read(iprot); + xfer += this->primaryKeys[_i902].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 _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->foreignKeys.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size903; + ::apache::thrift::protocol::TType _etype906; + xfer += iprot->readListBegin(_etype906, _size903); + this->foreignKeys.resize(_size903); + uint32_t _i907; + for (_i907 = 0; _i907 < _size903; ++_i907) { - xfer += this->foreignKeys[_i908].read(iprot); + xfer += this->foreignKeys[_i907].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 _iter909; - for (_iter909 = this->primaryKeys.begin(); _iter909 != this->primaryKeys.end(); ++_iter909) + std::vector<SQLPrimaryKey> ::const_iterator _iter908; + for (_iter908 = this->primaryKeys.begin(); _iter908 != this->primaryKeys.end(); ++_iter908) { - xfer += (*_iter909).write(oprot); + xfer += (*_iter908).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 _iter910; - for (_iter910 = this->foreignKeys.begin(); _iter910 != this->foreignKeys.end(); ++_iter910) + std::vector<SQLForeignKey> ::const_iterator _iter909; + for (_iter909 = this->foreignKeys.begin(); _iter909 != this->foreignKeys.end(); ++_iter909) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter909).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 _iter911; - for (_iter911 = (*(this->primaryKeys)).begin(); _iter911 != (*(this->primaryKeys)).end(); ++_iter911) + std::vector<SQLPrimaryKey> ::const_iterator _iter910; + for (_iter910 = (*(this->primaryKeys)).begin(); _iter910 != (*(this->primaryKeys)).end(); ++_iter910) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter910).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 _iter912; - for (_iter912 = (*(this->foreignKeys)).begin(); _iter912 != (*(this->foreignKeys)).end(); ++_iter912) + std::vector<SQLForeignKey> ::const_iterator _iter911; + for (_iter911 = (*(this->foreignKeys)).begin(); _iter911 != (*(this->foreignKeys)).end(); ++_iter911) { - xfer += (*_iter912).write(oprot); + xfer += (*_iter911).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5976,14 +5976,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->partNames.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _size912; + ::apache::thrift::protocol::TType _etype915; + xfer += iprot->readListBegin(_etype915, _size912); + this->partNames.resize(_size912); + uint32_t _i916; + for (_i916 = 0; _i916 < _size912; ++_i916) { - xfer += iprot->readString(this->partNames[_i917]); + xfer += iprot->readString(this->partNames[_i916]); } xfer += iprot->readListEnd(); } @@ -6020,10 +6020,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); - std::vector<std::string> ::const_iterator _iter918; - for (_iter918 = this->partNames.begin(); _iter918 != this->partNames.end(); ++_iter918) + std::vector<std::string> ::const_iterator _iter917; + for (_iter917 = this->partNames.begin(); _iter917 != this->partNames.end(); ++_iter917) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter917)); } xfer += oprot->writeListEnd(); } @@ -6055,10 +6055,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size())); - std::vector<std::string> ::const_iterator _iter919; - for (_iter919 = (*(this->partNames)).begin(); _iter919 != (*(this->partNames)).end(); ++_iter919) + std::vector<std::string> ::const_iterator _iter918; + for (_iter918 = (*(this->partNames)).begin(); _iter918 != (*(this->partNames)).end(); ++_iter918) { - xfer += oprot->writeString((*_iter919)); + xfer += oprot->writeString((*_iter918)); } xfer += oprot->writeListEnd(); } @@ -6302,14 +6302,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size920; - ::apache::thrift::protocol::TType _etype923; - xfer += iprot->readListBegin(_etype923, _size920); - this->success.resize(_size920); - uint32_t _i924; - for (_i924 = 0; _i924 < _size920; ++_i924) + uint32_t _size919; + ::apache::thrift::protocol::TType _etype922; + xfer += iprot->readListBegin(_etype922, _size919); + this->success.resize(_size919); + uint32_t _i923; + for (_i923 = 0; _i923 < _size919; ++_i923) { - xfer += iprot->readString(this->success[_i924]); + xfer += iprot->readString(this->success[_i923]); } xfer += iprot->readListEnd(); } @@ -6348,10 +6348,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 _iter925; - for (_iter925 = this->success.begin(); _iter925 != this->success.end(); ++_iter925) + std::vector<std::string> ::const_iterator _iter924; + for (_iter924 = this->success.begin(); _iter924 != this->success.end(); ++_iter924) { - xfer += oprot->writeString((*_iter925)); + xfer += oprot->writeString((*_iter924)); } xfer += oprot->writeListEnd(); } @@ -6396,14 +6396,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol 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 _size925; + ::apache::thrift::protocol::TType _etype928; + xfer += iprot->readListBegin(_etype928, _size925); + (*(this->success)).resize(_size925); + uint32_t _i929; + for (_i929 = 0; _i929 < _size925; ++_i929) { - xfer += iprot->readString((*(this->success))[_i930]); + xfer += iprot->readString((*(this->success))[_i929]); } xfer += iprot->readListEnd(); } @@ -6573,14 +6573,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size931; - ::apache::thrift::protocol::TType _etype934; - xfer += iprot->readListBegin(_etype934, _size931); - this->success.resize(_size931); - uint32_t _i935; - for (_i935 = 0; _i935 < _size931; ++_i935) + uint32_t _size930; + ::apache::thrift::protocol::TType _etype933; + xfer += iprot->readListBegin(_etype933, _size930); + this->success.resize(_size930); + uint32_t _i934; + for (_i934 = 0; _i934 < _size930; ++_i934) { - xfer += iprot->readString(this->success[_i935]); + xfer += iprot->readString(this->success[_i934]); } xfer += iprot->readListEnd(); } @@ -6619,10 +6619,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter936; - for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) + std::vector<std::string> ::const_iterator _iter935; + for (_iter935 = this->success.begin(); _iter935 != this->success.end(); ++_iter935) { - xfer += oprot->writeString((*_iter936)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -6667,14 +6667,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size937; - ::apache::thrift::protocol::TType _etype940; - xfer += iprot->readListBegin(_etype940, _size937); - (*(this->success)).resize(_size937); - uint32_t _i941; - for (_i941 = 0; _i941 < _size937; ++_i941) + uint32_t _size936; + ::apache::thrift::protocol::TType _etype939; + xfer += iprot->readListBegin(_etype939, _size936); + (*(this->success)).resize(_size936); + uint32_t _i940; + for (_i940 = 0; _i940 < _size936; ++_i940) { - xfer += iprot->readString((*(this->success))[_i941]); + xfer += iprot->readString((*(this->success))[_i940]); } xfer += iprot->readListEnd(); } @@ -6749,14 +6749,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 _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->tbl_types.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size941; + ::apache::thrift::protocol::TType _etype944; + xfer += iprot->readListBegin(_etype944, _size941); + this->tbl_types.resize(_size941); + uint32_t _i945; + for (_i945 = 0; _i945 < _size941; ++_i945) { - xfer += iprot->readString(this->tbl_types[_i946]); + xfer += iprot->readString(this->tbl_types[_i945]); } xfer += iprot->readListEnd(); } @@ -6793,10 +6793,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 _iter947; - for (_iter947 = this->tbl_types.begin(); _iter947 != this->tbl_types.end(); ++_iter947) + std::vector<std::string> ::const_iterator _iter946; + for (_iter946 = this->tbl_types.begin(); _iter946 != this->tbl_types.end(); ++_iter946) { - xfer += oprot->writeString((*_iter947)); + xfer += oprot->writeString((*_iter946)); } xfer += oprot->writeListEnd(); } @@ -6828,10 +6828,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 _iter948; - for (_iter948 = (*(this->tbl_types)).begin(); _iter948 != (*(this->tbl_types)).end(); ++_iter948) + std::vector<std::string> ::const_iterator _iter947; + for (_iter947 = (*(this->tbl_types)).begin(); _iter947 != (*(this->tbl_types)).end(); ++_iter947) { - xfer += oprot->writeString((*_iter948)); + xfer += oprot->writeString((*_iter947)); } xfer += oprot->writeListEnd(); } @@ -6872,14 +6872,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - this->success.resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + uint32_t _size948; + ::apache::thrift::protocol::TType _etype951; + xfer += iprot->readListBegin(_etype951, _size948); + this->success.resize(_size948); + uint32_t _i952; + for (_i952 = 0; _i952 < _size948; ++_i952) { - xfer += this->success[_i953].read(iprot); + xfer += this->success[_i952].read(iprot); } xfer += iprot->readListEnd(); } @@ -6918,10 +6918,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 _iter954; - for (_iter954 = this->success.begin(); _iter954 != this->success.end(); ++_iter954) + std::vector<TableMeta> ::const_iterator _iter953; + for (_iter953 = this->success.begin(); _iter953 != this->success.end(); ++_iter953) { - xfer += (*_iter954).write(oprot); + xfer += (*_iter953).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6966,14 +6966,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - (*(this->success)).resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + uint32_t _size954; + ::apache::thrift::protocol::TType _etype957; + xfer += iprot->readListBegin(_etype957, _size954); + (*(this->success)).resize(_size954); + uint32_t _i958; + for (_i958 = 0; _i958 < _size954; ++_i958) { - xfer += (*(this->success))[_i959].read(iprot); + xfer += (*(this->success))[_i958].read(iprot); } xfer += iprot->readListEnd(); } @@ -7111,14 +7111,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size960; - ::apache::thrift::protocol::TType _etype963; - xfer += iprot->readListBegin(_etype963, _size960); - this->success.resize(_size960); - uint32_t _i964; - for (_i964 = 0; _i964 < _size960; ++_i964) + uint32_t _size959; + ::apache::thrift::protocol::TType _etype962; + xfer += iprot->readListBegin(_etype962, _size959); + this->success.resize(_size959); + uint32_t _i963; + for (_i963 = 0; _i963 < _size959; ++_i963) { - xfer += iprot->readString(this->success[_i964]); + xfer += iprot->readString(this->success[_i963]); } xfer += iprot->readListEnd(); } @@ -7157,10 +7157,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 _iter965; - for (_iter965 = this->success.begin(); _iter965 != this->success.end(); ++_iter965) + std::vector<std::string> ::const_iterator _iter964; + for (_iter964 = this->success.begin(); _iter964 != this->success.end(); ++_iter964) { - xfer += oprot->writeString((*_iter965)); + xfer += oprot->writeString((*_iter964)); } xfer += oprot->writeListEnd(); } @@ -7205,14 +7205,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size966; - ::apache::thrift::protocol::TType _etype969; - xfer += iprot->readListBegin(_etype969, _size966); - (*(this->success)).resize(_size966); - uint32_t _i970; - for (_i970 = 0; _i970 < _size966; ++_i970) + uint32_t _size965; + ::apache::thrift::protocol::TType _etype968; + xfer += iprot->readListBegin(_etype968, _size965); + (*(this->success)).resize(_size965); + uint32_t _i969; + for (_i969 = 0; _i969 < _size965; ++_i969) { - xfer += iprot->readString((*(this->success))[_i970]); + xfer += iprot->readString((*(this->success))[_i969]); } xfer += iprot->readListEnd(); } @@ -7522,14 +7522,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 _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->tbl_names.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size970; + ::apache::thrift::protocol::TType _etype973; + xfer += iprot->readListBegin(_etype973, _size970); + this->tbl_names.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += iprot->readString(this->tbl_names[_i975]); + xfer += iprot->readString(this->tbl_names[_i974]); } xfer += iprot->readListEnd(); } @@ -7562,10 +7562,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 _iter976; - for (_iter976 = this->tbl_names.begin(); _iter976 != this->tbl_names.end(); ++_iter976) + std::vector<std::string> ::const_iterator _iter975; + for (_iter975 = this->tbl_names.begin(); _iter975 != this->tbl_names.end(); ++_iter975) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -7593,10 +7593,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 _iter977; - for (_iter977 = (*(this->tbl_names)).begin(); _iter977 != (*(this->tbl_names)).end(); ++_iter977) + std::vector<std::string> ::const_iterator _iter976; + for (_iter976 = (*(this->tbl_names)).begin(); _iter976 != (*(this->tbl_names)).end(); ++_iter976) { - xfer += oprot->writeString((*_iter977)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -7637,14 +7637,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 _size978; - ::apache::thrift::protocol::TType _etype981; - xfer += iprot->readListBegin(_etype981, _size978); - this->success.resize(_size978); - uint32_t _i982; - for (_i982 = 0; _i982 < _size978; ++_i982) + uint32_t _size977; + ::apache::thrift::protocol::TType _etype980; + xfer += iprot->readListBegin(_etype980, _size977); + this->success.resize(_size977); + uint32_t _i981; + for (_i981 = 0; _i981 < _size977; ++_i981) { - xfer += this->success[_i982].read(iprot); + xfer += this->success[_i981].read(iprot); } xfer += iprot->readListEnd(); } @@ -7675,10 +7675,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 _iter983; - for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) + std::vector<Table> ::const_iterator _iter982; + for (_iter982 = this->success.begin(); _iter982 != this->success.end(); ++_iter982) { - xfer += (*_iter983).write(oprot); + xfer += (*_iter982).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7719,14 +7719,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 _size984; - ::apache::thrift::protocol::TType _etype987; - xfer += iprot->readListBegin(_etype987, _size984); - (*(this->success)).resize(_size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size983; + ::apache::thrift::protocol::TType _etype986; + xfer += iprot->readListBegin(_etype986, _size983); + (*(this->success)).resize(_size983); + uint32_t _i987; + for (_i987 = 0; _i987 < _size983; ++_i987) { - xfer += (*(this->success))[_i988].read(iprot); + xfer += (*(this->success))[_i987].read(iprot); } xfer += iprot->readListEnd(); } @@ -8362,14 +8362,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 _size989; - ::apache::thrift::protocol::TType _etype992; - xfer += iprot->readListBegin(_etype992, _size989); - this->success.resize(_size989); - uint32_t _i993; - for (_i993 = 0; _i993 < _size989; ++_i993) + 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) { - xfer += iprot->readString(this->success[_i993]); + xfer += iprot->readString(this->success[_i992]); } xfer += iprot->readListEnd(); } @@ -8424,10 +8424,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 _iter994; - for (_iter994 = this->success.begin(); _iter994 != this->success.end(); ++_iter994) + std::vector<std::string> ::const_iterator _iter993; + for (_iter993 = this->success.begin(); _iter993 != this->success.end(); ++_iter993) { - xfer += oprot->writeString((*_iter994)); + xfer += oprot->writeString((*_iter993)); } xfer += oprot->writeListEnd(); } @@ -8480,14 +8480,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 _size995; - ::apache::thrift::protocol::TType _etype998; - xfer += iprot->readListBegin(_etype998, _size995); - (*(this->success)).resize(_size995); - uint32_t _i999; - for (_i999 = 0; _i999 < _size995; ++_i999) + uint32_t _size994; + ::apache::thrift::protocol::TType _etype997; + xfer += iprot->readListBegin(_etype997, _size994); + (*(this->success)).resize(_size994); + uint32_t _i998; + for (_i998 = 0; _i998 < _size994; ++_i998) { - xfer += iprot->readString((*(this->success))[_i999]); + xfer += iprot->readString((*(this->success))[_i998]); } xfer += iprot->readListEnd(); } @@ -9821,14 +9821,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1000; - ::apache::thrift::protocol::TType _etype1003; - xfer += iprot->readListBegin(_etype1003, _size1000); - this->new_parts.resize(_size1000); - uint32_t _i1004; - for (_i1004 = 0; _i1004 < _size1000; ++_i1004) + uint32_t _size999; + ::apache::thrift::protocol::TType _etype1002; + xfer += iprot->readListBegin(_etype1002, _size999); + this->new_parts.resize(_size999); + uint32_t _i1003; + for (_i1003 = 0; _i1003 < _size999; ++_i1003) { - xfer += this->new_parts[_i1004].read(iprot); + xfer += this->new_parts[_i1003].read(iprot); } xfer += iprot->readListEnd(); } @@ -9857,10 +9857,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 _iter1005; - for (_iter1005 = this->new_parts.begin(); _iter1005 != this->new_parts.end(); ++_iter1005) + std::vector<Partition> ::const_iterator _iter1004; + for (_iter1004 = this->new_parts.begin(); _iter1004 != this->new_parts.end(); ++_iter1004) { - xfer += (*_iter1005).write(oprot); + xfer += (*_iter1004).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9884,10 +9884,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 _iter1006; - for (_iter1006 = (*(this->new_parts)).begin(); _iter1006 != (*(this->new_parts)).end(); ++_iter1006) + std::vector<Partition> ::const_iterator _iter1005; + for (_iter1005 = (*(this->new_parts)).begin(); _iter1005 != (*(this->new_parts)).end(); ++_iter1005) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1005).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10096,14 +10096,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 _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - this->new_parts.resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1006; + ::apache::thrift::protocol::TType _etype1009; + xfer += iprot->readListBegin(_etype1009, _size1006); + this->new_parts.resize(_size1006); + uint32_t _i1010; + for (_i1010 = 0; _i1010 < _size1006; ++_i1010) { - xfer += this->new_parts[_i1011].read(iprot); + xfer += this->new_parts[_i1010].read(iprot); } xfer += iprot->readListEnd(); } @@ -10132,10 +10132,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 _iter1012; - for (_iter1012 = this->new_parts.begin(); _iter1012 != this->new_parts.end(); ++_iter1012) + std::vector<PartitionSpec> ::const_iterator _iter1011; + for (_iter1011 = this->new_parts.begin(); _iter1011 != this->new_parts.end(); ++_iter1011) { - xfer += (*_iter1012).write(oprot); + xfer += (*_iter1011).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10159,10 +10159,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 _iter1013; - for (_iter1013 = (*(this->new_parts)).begin(); _iter1013 != (*(this->new_parts)).end(); ++_iter1013) + std::vector<PartitionSpec> ::const_iterator _iter1012; + for (_iter1012 = (*(this->new_parts)).begin(); _iter1012 != (*(this->new_parts)).end(); ++_iter1012) { - xfer += (*_iter1013).write(oprot); + xfer += (*_iter1012).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10387,14 +10387,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1014; - ::apache::thrift::protocol::TType _etype1017; - xfer += iprot->readListBegin(_etype1017, _size1014); - this->part_vals.resize(_size1014); - uint32_t _i1018; - for (_i1018 = 0; _i1018 < _size1014; ++_i1018) + uint32_t _size1013; + ::apache::thrift::protocol::TType _etype1016; + xfer += iprot->readListBegin(_etype1016, _size1013); + this->part_vals.resize(_size1013); + uint32_t _i1017; + for (_i1017 = 0; _i1017 < _size1013; ++_i1017) { - xfer += iprot->readString(this->part_vals[_i1018]); + xfer += iprot->readString(this->part_vals[_i1017]); } xfer += iprot->readListEnd(); } @@ -10431,10 +10431,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 _iter1019; - for (_iter1019 = this->part_vals.begin(); _iter1019 != this->part_vals.end(); ++_iter1019) + std::vector<std::string> ::const_iterator _iter1018; + for (_iter1018 = this->part_vals.begin(); _iter1018 != this->part_vals.end(); ++_iter1018) { - xfer += oprot->writeString((*_iter1019)); + xfer += oprot->writeString((*_iter1018)); } xfer += oprot->writeListEnd(); } @@ -10466,10 +10466,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 _iter1020; - for (_iter1020 = (*(this->part_vals)).begin(); _iter1020 != (*(this->part_vals)).end(); ++_iter1020) + std::vector<std::string> ::const_iterator _iter1019; + for (_iter1019 = (*(this->part_vals)).begin(); _iter1019 != (*(this->part_vals)).end(); ++_iter1019) { - xfer += oprot->writeString((*_iter1020)); + xfer += oprot->writeString((*_iter1019)); } xfer += oprot->writeListEnd(); } @@ -10941,14 +10941,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->part_vals.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1020; + ::apache::thrift::protocol::TType _etype1023; + xfer += iprot->readListBegin(_etype1023, _size1020); + this->part_vals.resize(_size1020); + uint32_t _i1024; + for (_i1024 = 0; _i1024 < _size1020; ++_i1024) { - xfer += iprot->readString(this->part_vals[_i1025]); + xfer += iprot->readString(this->part_vals[_i1024]); } xfer += iprot->readListEnd(); } @@ -10993,10 +10993,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 _iter1026; - for (_iter1026 = this->part_vals.begin(); _iter1026 != this->part_vals.end(); ++_iter1026) + std::vector<std::string> ::const_iterator _iter1025; + for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1025)); } xfer += oprot->writeListEnd(); } @@ -11032,10 +11032,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 _iter1027; - for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) + std::vector<std::string> ::const_iterator _iter1026; + for (_iter1026 = (*(this->part_vals)).begin(); _iter1026 != (*(this->part_vals)).end(); ++_iter1026) { - xfer += oprot->writeString((*_iter1027)); + xfer += oprot->writeString((*_iter1026)); } xfer += oprot->writeListEnd(); } @@ -11838,14 +11838,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1028; - ::apache::thrift::protocol::TType _etype1031; - xfer += iprot->readListBegin(_etype1031, _size1028); - this->part_vals.resize(_size1028); - uint32_t _i1032; - for (_i1032 = 0; _i1032 < _size1028; ++_i1032) + uint32_t _size1027; + ::apache::thrift::protocol::TType _etype1030; + xfer += iprot->readListBegin(_etype1030, _size1027); + this->part_vals.resize(_size1027); + uint32_t _i1031; + for (_i1031 = 0; _i1031 < _size1027; ++_i1031) { - xfer += iprot->readString(this->part_vals[_i1032]); + xfer += iprot->readString(this->part_vals[_i1031]); } xfer += iprot->readListEnd(); } @@ -11890,10 +11890,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 _iter1033; - for (_iter1033 = this->part_vals.begin(); _iter1033 != this->part_vals.end(); ++_iter1033) + std::vector<std::string> ::const_iterator _iter1032; + for (_iter1032 = this->part_vals.begin(); _iter1032 != this->part_vals.end(); ++_iter1032) { - xfer += oprot->writeString((*_iter1033)); + xfer += oprot->writeString((*_iter1032)); } xfer += oprot->writeListEnd(); } @@ -11929,10 +11929,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 _iter1034; - for (_iter1034 = (*(this->part_vals)).begin(); _iter1034 != (*(this->part_vals)).end(); ++_iter1034) + std::vector<std::string> ::const_iterator _iter1033; + for (_iter1033 = (*(this->part_vals)).begin(); _iter1033 != (*(this->part_vals)).end(); ++_iter1033) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1033)); } xfer += oprot->writeListEnd(); } @@ -12141,14 +12141,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - this->part_vals.resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + uint32_t _size1034; + ::apache::thrift::protocol::TType _etype1037; + xfer += iprot->readListBegin(_etype1037, _size1034); + this->part_vals.resize(_size1034); + uint32_t _i1038; + for (_i1038 = 0; _i1038 < _size1034; ++_i1038) { - xfer += iprot->readString(this->part_vals[_i1039]); + xfer += iprot->readString(this->part_vals[_i1038]); } xfer += iprot->readListEnd(); } @@ -12201,10 +12201,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 _iter1040; - for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) + std::vector<std::string> ::const_iterator _iter1039; + for (_iter1039 = this->part_vals.begin(); _iter1039 != this->part_vals.end(); ++_iter1039) { - xfer += oprot->writeString((*_iter1040)); + xfer += oprot->writeString((*_iter1039)); } xfer += oprot->writeListEnd(); } @@ -12244,10 +12244,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 _iter1041; - for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) + std::vector<std::string> ::const_iterator _iter1040; + for (_iter1040 = (*(this->part_vals)).begin(); _iter1040 != (*(this->part_vals)).end(); ++_iter1040) { - xfer += oprot->writeString((*_iter1041)); + xfer += oprot->writeString((*_iter1040)); } xfer += oprot->writeListEnd(); } @@ -13253,14 +13253,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1042; - ::apache::thrift::protocol::TType _etype1045; - xfer += iprot->readListBegin(_etype1045, _size1042); - this->part_vals.resize(_size1042); - uint32_t _i1046; - for (_i1046 = 0; _i1046 < _size1042; ++_i1046) + uint32_t _size1041; + ::apache::thrift::protocol::TType _etype1044; + xfer += iprot->readListBegin(_etype1044, _size1041); + this->part_vals.resize(_size1041); + uint32_t _i1045; + for (_i1045 = 0; _i1045 < _size1041; ++_i1045) { - xfer += iprot->readString(this->part_vals[_i1046]); + xfer += iprot->readString(this->part_vals[_i1045]); } xfer += iprot->readListEnd(); } @@ -13297,10 +13297,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 _iter1047; - for (_iter1047 = this->part_vals.begin(); _iter1047 != this->part_vals.end(); ++_iter1047) + std::vector<std::string> ::const_iterator _iter1046; + for (_iter1046 = this->part_vals.begin(); _iter1046 != this->part_vals.end(); ++_iter1046) { - xfer += oprot->writeString((*_iter1047)); + xfer += oprot->writeString((*_iter1046)); } xfer += oprot->writeListEnd(); } @@ -13332,10 +13332,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 _iter1048; - for (_iter1048 = (*(this->part_vals)).begin(); _iter1048 != (*(this->part_vals)).end(); ++_iter1048) + std::vector<std::string> ::const_iterator _iter1047; + for (_iter1047 = (*(this->part_vals)).begin(); _iter1047 != (*(this->part_vals)).end(); ++_iter1047) { - xfer += oprot->writeString((*_iter1048)); + xfer += oprot->writeString((*_iter1047)); } xfer += oprot->writeListEnd(); } @@ -13524,17 +13524,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1049; - ::apache::thrift::protocol::TType _ktype1050; - ::apache::thrift::protocol::TType _vtype1051; - xfer += iprot->readMapBegin(_ktype1050, _vtype1051, _size1049); - uint32_t _i1053; - for (_i1053 = 0; _i1053 < _size1049; ++_i1053) + uint32_t _size1048; + ::apache::thrift::protocol::TType _ktype1049; + ::apache::thrift::protocol::TType _vtype1050; + xfer += iprot->readMapBegin(_ktype1049, _vtype1050, _size1048); + uint32_t _i1052; + for (_i1052 = 0; _i1052 < _size1048; ++_i1052) { - std::string _key1054; - xfer += iprot->readString(_key1054); - std::string& _val1055 = this->partitionSpecs[_key1054]; - xfer += iprot->readString(_val1055); + std::string _key1053; + xfer += iprot->readString(_key1053); + std::string& _val1054 = this->partitionSpecs[_key1053]; + xfer += iprot->readString(_val1054); } xfer += iprot->readMapEnd(); } @@ -13595,11 +13595,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 _iter1056; - for (_iter1056 = this->partitionSpecs.begin(); _iter1056 != this->partitionSpecs.end(); ++_iter1056) + std::map<std::string, std::string> ::const_iterator _iter1055; + for (_iter1055 = this->partitionSpecs.begin(); _iter1055 != this->partitionSpecs.end(); ++_iter1055) { - xfer += oprot->writeString(_iter1056->first); - xfer += oprot->writeString(_iter1056->second); + xfer += oprot->writeString(_iter1055->first); + xfer += oprot->writeString(_iter1055->second); } xfer += oprot->writeMapEnd(); } @@ -13639,11 +13639,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 _iter1057; - for (_iter1057 = (*(this->partitionSpecs)).begin(); _iter1057 != (*(this->partitionSpecs)).end(); ++_iter1057) + std::map<std::string, std::string> ::const_iterator _iter1056; + for (_iter1056 = (*(this->partitionSpecs)).begin(); _iter1056 != (*(this->partitionSpecs)).end(); ++_iter1056) { - xfer += oprot->writeString(_iter1057->first); - xfer += oprot->writeString(_iter1057->second); + xfer += oprot->writeString(_iter1056->first); + xfer += oprot->writeString(_iter1056->second); } xfer += oprot->writeMapEnd(); } @@ -13888,17 +13888,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1058; - ::apache::thrift::protocol::TType _ktype1059; - ::apache::thrift::protocol::TType _vtype1060; - xfer += iprot->readMapBegin(_ktype1059, _vtype1060, _size1058); - uint32_t _i1062; - for (_i1062 = 0; _i1062 < _size1058; ++_i1062) + uint32_t _size1057; + ::apache::thrift::protocol::TType _ktype1058; + ::apache::thrift::protocol::TType _vtype1059; + xfer += iprot->readMapBegin(_ktype1058, _vtype1059, _size1057); + uint32_t _i1061; + for (_i1061 = 0; _i1061 < _size1057; ++_i1061) { - std::string _key1063; - xfer += iprot->readString(_key1063); - std::string& _val1064 = this->partitionSpecs[_key1063]; - xfer += iprot->readString(_val1064); + std::string _key1062; + xfer += iprot->readString(_key1062); + std::string& _val1063 = this->partitionSpecs[_key1062]; + xfer += iprot->readString(_val1063); } xfer += iprot->readMapEnd(); } @@ -13959,11 +13959,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 _iter1065; - for (_iter1065 = this->partitionSpecs.begin(); _iter1065 != this->partitionSpecs.end(); ++_iter1065) + std::map<std::string, std::string> ::const_iterator _iter1064; + for (_iter1064 = this->partitionSpecs.begin(); _iter1064 != this->partitionSpecs.end(); ++_iter1064) { - xfer += oprot->writeString(_iter1065->first); - xfer += oprot->writeString(_iter1065->second); + xfer += oprot->writeString(_iter1064->first); + xfer += oprot->writeString(_iter1064->second); } xfer += oprot->writeMapEnd(); } @@ -14003,11 +14003,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 _iter1066; - for (_iter1066 = (*(this->partitionSpecs)).begin(); _iter1066 != (*(this->partitionSpecs)).end(); ++_iter1066) + std::map<std::string, std::string> ::const_iterator _iter1065; + for (_iter1065 = (*(this->partitionSpecs)).begin(); _iter1065 != (*(this->partitionSpecs)).end(); ++_iter1065) { - xfer += oprot->writeString(_iter1066->first); - xfer += oprot->writeString(_iter1066->second); + xfer += oprot->writeString(_iter1065->first); + xfer += oprot->writeString(_iter1065->second); } xfer += oprot->writeMapEnd(); } @@ -14064,14 +14064,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->success.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + 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[_i1071].read(iprot); + xfer += this->success[_i1070].read(iprot); } xfer += iprot->readListEnd(); } @@ -14134,10 +14134,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 _iter1072; - for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) + std::vector<Partition> ::const_iterator _iter1071; + for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) { - xfer += (*_iter1072).write(oprot); + xfer += (*_iter1071).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14194,14 +14194,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1073; - ::apache::thrift::protocol::TType _etype1076; - xfer += iprot->readListBegin(_etype1076, _size1073); - (*(this->success)).resize(_size1073); - uint32_t _i1077; - for (_i1077 = 0; _i1077 < _size1073; ++_i1077) + 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))[_i1077].read(iprot); + xfer += (*(this->success))[_i1076].read(iprot); } xfer += iprot->readListEnd(); } @@ -14300,14 +14300,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 _size1078; - ::apache::thrift::protocol::TType _etype1081; - xfer += iprot->readListBegin(_etype1081, _size1078); - this->part_vals.resize(_size1078); - uint32_t _i1082; - for (_i1082 = 0; _i1082 < _size1078; ++_i1082) + uint32_t _size1077; + ::apache::thrift::protocol::TType _etype1080; + xfer += iprot->readListBegin(_etype1080, _size1077); + this->part_vals.resize(_size1077); + uint32_t _i1081; + for (_i1081 = 0; _i1081 < _size1077; ++_i1081) { - xfer += iprot->readString(this->part_vals[_i1082]); + xfer += iprot->readString(this->part_vals[_i1081]); } xfer += iprot->readListEnd(); } @@ -14328,14 +14328,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 _size1083; - ::apache::thrift::protocol::TType _etype1086; - xfer += iprot->readListBegin(_etype1086, _size1083); - this->group_names.resize(_size1083); - uint32_t _i1087; - for (_i1087 = 0; _i1087 < _size1083; ++_i1087) + uint32_t _size1082; + ::apache::thrift::protocol::TType _etype1085; + xfer += iprot->readListBegin(_etype1085, _size1082); + this->group_names.resize(_size1082); + uint32_t _i1086; + for (_i1086 = 0; _i1086 < _size1082; ++_i1086) { - xfer += iprot->readString(this->group_names[_i1087]); + xfer += iprot->readString(this->group_names[_i1086]); } xfer += iprot->readListEnd(); } @@ -14372,10 +14372,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 _iter1088; - for (_iter1088 = this->part_vals.begin(); _iter1088 != this->part_vals.end(); ++_iter1088) + std::vector<std::string> ::const_iterator _iter1087; + for (_iter1087 = this->part_vals.begin(); _iter1087 != this->part_vals.end(); ++_iter1087) { - xfer += oprot->writeString((*_iter1088)); + xfer += oprot->writeString((*_iter1087)); } xfer += oprot->writeListEnd(); } @@ -14388,10 +14388,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 _iter1089; - for (_iter1089 = this->group_names.begin(); _iter1089 != this->group_names.end(); ++_iter1089) + std::vector<std::string> ::const_iterator _iter1088; + for (_iter1088 = this->group_names.begin(); _iter1088 != this->group_names.end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1089)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -14423,10 +14423,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 _iter1090; - for (_iter1090 = (*(this->part_vals)).begin(); _iter1090 != (*(this->part_vals)).end(); ++_iter1090) + std::vector<std::string> ::const_iterator _iter1089; + for (_iter1089 = (*(this->part_vals)).begin(); _iter1089 != (*(this->part_vals)).end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1090)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -14439,10 +14439,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 _iter1091; - for (_iter1091 = (*(this->group_names)).begin(); _iter1091 != (*(this->group_names)).end(); ++_iter1091) + std::vector<std::string> ::const_iterator _iter1090; + for (_iter1090 = (*(this->group_names)).begin(); _iter1090 != (*(this->group_names)).end(); ++_iter1090) { - xfer += oprot->writeString((*_iter1091)); + xfer += oprot->writeString((*_iter1090)); } xfer += oprot->writeListEnd(); } @@ -15001,14 +15001,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1092; - ::apache::thrift::protocol::TType _etype1095; - xfer += iprot->readListBegin(_etype1095, _size1092); - this->success.resize(_size1092); - uint32_t _i1096; - for (_i1096 = 0; _i1096 < _size1092; ++_i1096) + uint32_t _size1091; + ::apache::thrift::protocol::TType _etype1094; + xfer += iprot->readListBegin(_etype1094, _size1091); + this->success.resize(_size1091); + uint32_t _i1095; + for (_i1095 = 0; _i1095 < _size1091; ++_i1095) { - xfer += this->success[_i1096].read(iprot); + xfer += this->success[_i1095].read(iprot); } xfer += iprot->readListEnd(); } @@ -15055,10 +15055,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 _iter1097; - for (_iter1097 = this->success.begin(); _iter1097 != this->success.end(); ++_iter1097) + std::vector<Partition> ::const_iterator _iter1096; + for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) { - xfer += (*_iter1097).write(oprot); + xfer += (*_iter1096).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15107,14 +15107,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1098; - ::apache::thrift::protocol::TType _etype1101; - xfer += iprot->readListBegin(_etype1101, _size1098); - (*(this->success)).resize(_size1098); - uint32_t _i1102; - for (_i1102 = 0; _i1102 < _size1098; ++_i1102) + uint32_t _size1097; + ::apache::thrift::protocol::TType _etype1100; + xfer += iprot->readListBegin(_etype1100, _size1097); + (*(this->success)).resize(_size1097); + uint32_t _i1101; + for (_i1101 = 0; _i1101 < _size1097; ++_i1101) { - xfer += (*(this->success))[_i1102].read(iprot); + xfer += (*(this->success))[_i1101].read(iprot); } xfer += iprot->readListEnd(); } @@ -15213,14 +15213,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 _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - this->group_names.resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1102; + ::apache::thrift::protocol::TType _etype1105; + xfer += iprot->readListBegin(_etype1105, _size1102); + this->group_names.resize(_size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - xfer += iprot->readString(this->group_names[_i1107]); + xfer += iprot->readString(this->group_names[_i1106]); } xfer += iprot->readListEnd(); } @@ -15265,10 +15265,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 _iter1108; - for (_iter1108 = this->group_names.begin(); _iter1108 != this->group_names.end(); ++_iter1108) + std::vector<std::string> ::const_iterator _iter1107; + for (_iter1107 = this->group_names.begin(); _iter1107 != this->group_names.end(); ++_iter1107) { - xfer += oprot->writeString((*_iter1108)); + xfer += oprot->writeString((*_iter1107)); } xfer += oprot->writeListEnd(); } @@ -15308,10 +15308,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 _iter1109; - for (_iter1109 = (*(this->group_names)).begin(); _iter1109 != (*(this->group_names)).end(); ++_iter1109) + std::vector<std::string> ::const_iterator _iter1108; + for (_iter1108 = (*(this->group_names)).begin(); _iter1108 != (*(this->group_names)).end(); ++_iter1108) { - xfer += oprot->writeString((*_iter1109)); + xfer += oprot->writeString((*_iter1108)); } xfer += oprot->writeListEnd(); } @@ -15352,14 +15352,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1110; - ::apache::thrift::protocol::TType _etype1113; - xfer += iprot->readListBegin(_etype1113, _size1110); - this->success.resize(_size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1109; + ::apache::thrift::protocol::TType _etype1112; + xfer += iprot->readListBegin(_etype1112, _size1109); + this->success.resize(_size1109); + uint32_t _i1113; + for (_i1113 = 0; _i1113 < _size1109; ++_i1113) { - xfer += thi
<TRUNCATED>
