http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/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 5ed3912..0b6fe91 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 _size793; - ::apache::thrift::protocol::TType _etype796; - xfer += iprot->readListBegin(_etype796, _size793); - this->success.resize(_size793); - uint32_t _i797; - for (_i797 = 0; _i797 < _size793; ++_i797) + uint32_t _size803; + ::apache::thrift::protocol::TType _etype806; + xfer += iprot->readListBegin(_etype806, _size803); + this->success.resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += iprot->readString(this->success[_i797]); + xfer += iprot->readString(this->success[_i807]); } 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 _iter798; - for (_iter798 = this->success.begin(); _iter798 != this->success.end(); ++_iter798) + std::vector<std::string> ::const_iterator _iter808; + for (_iter808 = this->success.begin(); _iter808 != this->success.end(); ++_iter808) { - xfer += oprot->writeString((*_iter798)); + xfer += oprot->writeString((*_iter808)); } 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 _size799; - ::apache::thrift::protocol::TType _etype802; - xfer += iprot->readListBegin(_etype802, _size799); - (*(this->success)).resize(_size799); - uint32_t _i803; - for (_i803 = 0; _i803 < _size799; ++_i803) + uint32_t _size809; + ::apache::thrift::protocol::TType _etype812; + xfer += iprot->readListBegin(_etype812, _size809); + (*(this->success)).resize(_size809); + uint32_t _i813; + for (_i813 = 0; _i813 < _size809; ++_i813) { - xfer += iprot->readString((*(this->success))[_i803]); + xfer += iprot->readString((*(this->success))[_i813]); } 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 _size804; - ::apache::thrift::protocol::TType _etype807; - xfer += iprot->readListBegin(_etype807, _size804); - this->success.resize(_size804); - uint32_t _i808; - for (_i808 = 0; _i808 < _size804; ++_i808) + uint32_t _size814; + ::apache::thrift::protocol::TType _etype817; + xfer += iprot->readListBegin(_etype817, _size814); + this->success.resize(_size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - xfer += iprot->readString(this->success[_i808]); + xfer += iprot->readString(this->success[_i818]); } 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 _iter809; - for (_iter809 = this->success.begin(); _iter809 != this->success.end(); ++_iter809) + std::vector<std::string> ::const_iterator _iter819; + for (_iter819 = this->success.begin(); _iter819 != this->success.end(); ++_iter819) { - xfer += oprot->writeString((*_iter809)); + xfer += oprot->writeString((*_iter819)); } 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 _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 _size820; + ::apache::thrift::protocol::TType _etype823; + xfer += iprot->readListBegin(_etype823, _size820); + (*(this->success)).resize(_size820); + uint32_t _i824; + for (_i824 = 0; _i824 < _size820; ++_i824) { - xfer += iprot->readString((*(this->success))[_i814]); + xfer += iprot->readString((*(this->success))[_i824]); } 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 _size815; - ::apache::thrift::protocol::TType _ktype816; - ::apache::thrift::protocol::TType _vtype817; - xfer += iprot->readMapBegin(_ktype816, _vtype817, _size815); - uint32_t _i819; - for (_i819 = 0; _i819 < _size815; ++_i819) + uint32_t _size825; + ::apache::thrift::protocol::TType _ktype826; + ::apache::thrift::protocol::TType _vtype827; + xfer += iprot->readMapBegin(_ktype826, _vtype827, _size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - std::string _key820; - xfer += iprot->readString(_key820); - Type& _val821 = this->success[_key820]; - xfer += _val821.read(iprot); + std::string _key830; + xfer += iprot->readString(_key830); + Type& _val831 = this->success[_key830]; + xfer += _val831.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 _iter822; - for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) + std::map<std::string, Type> ::const_iterator _iter832; + for (_iter832 = this->success.begin(); _iter832 != this->success.end(); ++_iter832) { - xfer += oprot->writeString(_iter822->first); - xfer += _iter822->second.write(oprot); + xfer += oprot->writeString(_iter832->first); + xfer += _iter832->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 _size823; - ::apache::thrift::protocol::TType _ktype824; - ::apache::thrift::protocol::TType _vtype825; - xfer += iprot->readMapBegin(_ktype824, _vtype825, _size823); - uint32_t _i827; - for (_i827 = 0; _i827 < _size823; ++_i827) + uint32_t _size833; + ::apache::thrift::protocol::TType _ktype834; + ::apache::thrift::protocol::TType _vtype835; + xfer += iprot->readMapBegin(_ktype834, _vtype835, _size833); + uint32_t _i837; + for (_i837 = 0; _i837 < _size833; ++_i837) { - std::string _key828; - xfer += iprot->readString(_key828); - Type& _val829 = (*(this->success))[_key828]; - xfer += _val829.read(iprot); + std::string _key838; + xfer += iprot->readString(_key838); + Type& _val839 = (*(this->success))[_key838]; + xfer += _val839.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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - this->success.resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _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[_i834].read(iprot); + xfer += this->success[_i844].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 _iter835; - for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835) + std::vector<FieldSchema> ::const_iterator _iter845; + for (_iter845 = this->success.begin(); _iter845 != this->success.end(); ++_iter845) { - xfer += (*_iter835).write(oprot); + xfer += (*_iter845).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 _size836; - ::apache::thrift::protocol::TType _etype839; - xfer += iprot->readListBegin(_etype839, _size836); - (*(this->success)).resize(_size836); - uint32_t _i840; - for (_i840 = 0; _i840 < _size836; ++_i840) + 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))[_i840].read(iprot); + xfer += (*(this->success))[_i850].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 _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - this->success.resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + uint32_t _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[_i845].read(iprot); + xfer += this->success[_i855].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 _iter846; - for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) + std::vector<FieldSchema> ::const_iterator _iter856; + for (_iter856 = this->success.begin(); _iter856 != this->success.end(); ++_iter856) { - xfer += (*_iter846).write(oprot); + xfer += (*_iter856).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 _size847; - ::apache::thrift::protocol::TType _etype850; - xfer += iprot->readListBegin(_etype850, _size847); - (*(this->success)).resize(_size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + 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))[_i851].read(iprot); + xfer += (*(this->success))[_i861].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 _size852; - ::apache::thrift::protocol::TType _etype855; - xfer += iprot->readListBegin(_etype855, _size852); - this->success.resize(_size852); - uint32_t _i856; - for (_i856 = 0; _i856 < _size852; ++_i856) + uint32_t _size862; + ::apache::thrift::protocol::TType _etype865; + xfer += iprot->readListBegin(_etype865, _size862); + this->success.resize(_size862); + uint32_t _i866; + for (_i866 = 0; _i866 < _size862; ++_i866) { - xfer += this->success[_i856].read(iprot); + xfer += this->success[_i866].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 _iter857; - for (_iter857 = this->success.begin(); _iter857 != this->success.end(); ++_iter857) + std::vector<FieldSchema> ::const_iterator _iter867; + for (_iter867 = this->success.begin(); _iter867 != this->success.end(); ++_iter867) { - xfer += (*_iter857).write(oprot); + xfer += (*_iter867).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 _size858; - ::apache::thrift::protocol::TType _etype861; - xfer += iprot->readListBegin(_etype861, _size858); - (*(this->success)).resize(_size858); - uint32_t _i862; - for (_i862 = 0; _i862 < _size858; ++_i862) + 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) { - xfer += (*(this->success))[_i862].read(iprot); + xfer += (*(this->success))[_i872].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 _size863; - ::apache::thrift::protocol::TType _etype866; - xfer += iprot->readListBegin(_etype866, _size863); - this->success.resize(_size863); - uint32_t _i867; - for (_i867 = 0; _i867 < _size863; ++_i867) + uint32_t _size873; + ::apache::thrift::protocol::TType _etype876; + xfer += iprot->readListBegin(_etype876, _size873); + this->success.resize(_size873); + uint32_t _i877; + for (_i877 = 0; _i877 < _size873; ++_i877) { - xfer += this->success[_i867].read(iprot); + xfer += this->success[_i877].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 _iter868; - for (_iter868 = this->success.begin(); _iter868 != this->success.end(); ++_iter868) + std::vector<FieldSchema> ::const_iterator _iter878; + for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) { - xfer += (*_iter868).write(oprot); + xfer += (*_iter878).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 _size869; - ::apache::thrift::protocol::TType _etype872; - xfer += iprot->readListBegin(_etype872, _size869); - (*(this->success)).resize(_size869); - uint32_t _i873; - for (_i873 = 0; _i873 < _size869; ++_i873) + uint32_t _size879; + ::apache::thrift::protocol::TType _etype882; + xfer += iprot->readListBegin(_etype882, _size879); + (*(this->success)).resize(_size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - xfer += (*(this->success))[_i873].read(iprot); + xfer += (*(this->success))[_i883].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 _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - this->primaryKeys.resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + uint32_t _size884; + ::apache::thrift::protocol::TType _etype887; + xfer += iprot->readListBegin(_etype887, _size884); + this->primaryKeys.resize(_size884); + uint32_t _i888; + for (_i888 = 0; _i888 < _size884; ++_i888) { - xfer += this->primaryKeys[_i878].read(iprot); + xfer += this->primaryKeys[_i888].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 _size879; - ::apache::thrift::protocol::TType _etype882; - xfer += iprot->readListBegin(_etype882, _size879); - this->foreignKeys.resize(_size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size889; + ::apache::thrift::protocol::TType _etype892; + xfer += iprot->readListBegin(_etype892, _size889); + this->foreignKeys.resize(_size889); + uint32_t _i893; + for (_i893 = 0; _i893 < _size889; ++_i893) { - xfer += this->foreignKeys[_i883].read(iprot); + xfer += this->foreignKeys[_i893].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 _iter884; - for (_iter884 = this->primaryKeys.begin(); _iter884 != this->primaryKeys.end(); ++_iter884) + std::vector<SQLPrimaryKey> ::const_iterator _iter894; + for (_iter894 = this->primaryKeys.begin(); _iter894 != this->primaryKeys.end(); ++_iter894) { - xfer += (*_iter884).write(oprot); + xfer += (*_iter894).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 _iter885; - for (_iter885 = this->foreignKeys.begin(); _iter885 != this->foreignKeys.end(); ++_iter885) + std::vector<SQLForeignKey> ::const_iterator _iter895; + for (_iter895 = this->foreignKeys.begin(); _iter895 != this->foreignKeys.end(); ++_iter895) { - xfer += (*_iter885).write(oprot); + xfer += (*_iter895).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 _iter886; - for (_iter886 = (*(this->primaryKeys)).begin(); _iter886 != (*(this->primaryKeys)).end(); ++_iter886) + std::vector<SQLPrimaryKey> ::const_iterator _iter896; + for (_iter896 = (*(this->primaryKeys)).begin(); _iter896 != (*(this->primaryKeys)).end(); ++_iter896) { - xfer += (*_iter886).write(oprot); + xfer += (*_iter896).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 _iter887; - for (_iter887 = (*(this->foreignKeys)).begin(); _iter887 != (*(this->foreignKeys)).end(); ++_iter887) + std::vector<SQLForeignKey> ::const_iterator _iter897; + for (_iter897 = (*(this->foreignKeys)).begin(); _iter897 != (*(this->foreignKeys)).end(); ++_iter897) { - xfer += (*_iter887).write(oprot); + xfer += (*_iter897).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 _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 _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->success.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += iprot->readString(this->success[_i892]); + xfer += iprot->readString(this->success[_i902]); } 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 _iter893; - for (_iter893 = this->success.begin(); _iter893 != this->success.end(); ++_iter893) + std::vector<std::string> ::const_iterator _iter903; + for (_iter903 = this->success.begin(); _iter903 != this->success.end(); ++_iter903) { - xfer += oprot->writeString((*_iter893)); + xfer += oprot->writeString((*_iter903)); } 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 _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 _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + (*(this->success)).resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += iprot->readString((*(this->success))[_i898]); + xfer += iprot->readString((*(this->success))[_i908]); } 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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->tbl_types.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size909; + ::apache::thrift::protocol::TType _etype912; + xfer += iprot->readListBegin(_etype912, _size909); + this->tbl_types.resize(_size909); + uint32_t _i913; + for (_i913 = 0; _i913 < _size909; ++_i913) { - xfer += iprot->readString(this->tbl_types[_i903]); + xfer += iprot->readString(this->tbl_types[_i913]); } 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 _iter904; - for (_iter904 = this->tbl_types.begin(); _iter904 != this->tbl_types.end(); ++_iter904) + std::vector<std::string> ::const_iterator _iter914; + for (_iter914 = this->tbl_types.begin(); _iter914 != this->tbl_types.end(); ++_iter914) { - xfer += oprot->writeString((*_iter904)); + xfer += oprot->writeString((*_iter914)); } 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 _iter905; - for (_iter905 = (*(this->tbl_types)).begin(); _iter905 != (*(this->tbl_types)).end(); ++_iter905) + std::vector<std::string> ::const_iterator _iter915; + for (_iter915 = (*(this->tbl_types)).begin(); _iter915 != (*(this->tbl_types)).end(); ++_iter915) { - xfer += oprot->writeString((*_iter905)); + xfer += oprot->writeString((*_iter915)); } 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 _size906; - ::apache::thrift::protocol::TType _etype909; - xfer += iprot->readListBegin(_etype909, _size906); - this->success.resize(_size906); - uint32_t _i910; - for (_i910 = 0; _i910 < _size906; ++_i910) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->success.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += this->success[_i910].read(iprot); + xfer += this->success[_i920].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 _iter911; - for (_iter911 = this->success.begin(); _iter911 != this->success.end(); ++_iter911) + std::vector<TableMeta> ::const_iterator _iter921; + for (_iter921 = this->success.begin(); _iter921 != this->success.end(); ++_iter921) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter921).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 _size912; - ::apache::thrift::protocol::TType _etype915; - xfer += iprot->readListBegin(_etype915, _size912); - (*(this->success)).resize(_size912); - uint32_t _i916; - for (_i916 = 0; _i916 < _size912; ++_i916) + uint32_t _size922; + ::apache::thrift::protocol::TType _etype925; + xfer += iprot->readListBegin(_etype925, _size922); + (*(this->success)).resize(_size922); + uint32_t _i926; + for (_i926 = 0; _i926 < _size922; ++_i926) { - xfer += (*(this->success))[_i916].read(iprot); + xfer += (*(this->success))[_i926].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 _size917; - ::apache::thrift::protocol::TType _etype920; - xfer += iprot->readListBegin(_etype920, _size917); - this->success.resize(_size917); - uint32_t _i921; - for (_i921 = 0; _i921 < _size917; ++_i921) + uint32_t _size927; + ::apache::thrift::protocol::TType _etype930; + xfer += iprot->readListBegin(_etype930, _size927); + this->success.resize(_size927); + uint32_t _i931; + for (_i931 = 0; _i931 < _size927; ++_i931) { - xfer += iprot->readString(this->success[_i921]); + xfer += iprot->readString(this->success[_i931]); } 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 _iter922; - for (_iter922 = this->success.begin(); _iter922 != this->success.end(); ++_iter922) + std::vector<std::string> ::const_iterator _iter932; + for (_iter932 = this->success.begin(); _iter932 != this->success.end(); ++_iter932) { - xfer += oprot->writeString((*_iter922)); + xfer += oprot->writeString((*_iter932)); } 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 _size923; - ::apache::thrift::protocol::TType _etype926; - xfer += iprot->readListBegin(_etype926, _size923); - (*(this->success)).resize(_size923); - uint32_t _i927; - for (_i927 = 0; _i927 < _size923; ++_i927) + uint32_t _size933; + ::apache::thrift::protocol::TType _etype936; + xfer += iprot->readListBegin(_etype936, _size933); + (*(this->success)).resize(_size933); + uint32_t _i937; + for (_i937 = 0; _i937 < _size933; ++_i937) { - xfer += iprot->readString((*(this->success))[_i927]); + xfer += iprot->readString((*(this->success))[_i937]); } 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 _size928; - ::apache::thrift::protocol::TType _etype931; - xfer += iprot->readListBegin(_etype931, _size928); - this->tbl_names.resize(_size928); - uint32_t _i932; - for (_i932 = 0; _i932 < _size928; ++_i932) + uint32_t _size938; + ::apache::thrift::protocol::TType _etype941; + xfer += iprot->readListBegin(_etype941, _size938); + this->tbl_names.resize(_size938); + uint32_t _i942; + for (_i942 = 0; _i942 < _size938; ++_i942) { - xfer += iprot->readString(this->tbl_names[_i932]); + xfer += iprot->readString(this->tbl_names[_i942]); } 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 _iter933; - for (_iter933 = this->tbl_names.begin(); _iter933 != this->tbl_names.end(); ++_iter933) + std::vector<std::string> ::const_iterator _iter943; + for (_iter943 = this->tbl_names.begin(); _iter943 != this->tbl_names.end(); ++_iter943) { - xfer += oprot->writeString((*_iter933)); + xfer += oprot->writeString((*_iter943)); } 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 _iter934; - for (_iter934 = (*(this->tbl_names)).begin(); _iter934 != (*(this->tbl_names)).end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter944; + for (_iter944 = (*(this->tbl_names)).begin(); _iter944 != (*(this->tbl_names)).end(); ++_iter944) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter944)); } 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 _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->success.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size945; + ::apache::thrift::protocol::TType _etype948; + xfer += iprot->readListBegin(_etype948, _size945); + this->success.resize(_size945); + uint32_t _i949; + for (_i949 = 0; _i949 < _size945; ++_i949) { - xfer += this->success[_i939].read(iprot); + xfer += this->success[_i949].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 _iter940; - for (_iter940 = this->success.begin(); _iter940 != this->success.end(); ++_iter940) + std::vector<Table> ::const_iterator _iter950; + for (_iter950 = this->success.begin(); _iter950 != this->success.end(); ++_iter950) { - xfer += (*_iter940).write(oprot); + xfer += (*_iter950).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 _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - (*(this->success)).resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size951; + ::apache::thrift::protocol::TType _etype954; + xfer += iprot->readListBegin(_etype954, _size951); + (*(this->success)).resize(_size951); + uint32_t _i955; + for (_i955 = 0; _i955 < _size951; ++_i955) { - xfer += (*(this->success))[_i945].read(iprot); + xfer += (*(this->success))[_i955].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 _size946; - ::apache::thrift::protocol::TType _etype949; - xfer += iprot->readListBegin(_etype949, _size946); - this->success.resize(_size946); - uint32_t _i950; - for (_i950 = 0; _i950 < _size946; ++_i950) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->success.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += iprot->readString(this->success[_i950]); + xfer += iprot->readString(this->success[_i960]); } 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 _iter951; - for (_iter951 = this->success.begin(); _iter951 != this->success.end(); ++_iter951) + std::vector<std::string> ::const_iterator _iter961; + for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961) { - xfer += oprot->writeString((*_iter951)); + xfer += oprot->writeString((*_iter961)); } 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 _size952; - ::apache::thrift::protocol::TType _etype955; - xfer += iprot->readListBegin(_etype955, _size952); - (*(this->success)).resize(_size952); - uint32_t _i956; - for (_i956 = 0; _i956 < _size952; ++_i956) + uint32_t _size962; + ::apache::thrift::protocol::TType _etype965; + xfer += iprot->readListBegin(_etype965, _size962); + (*(this->success)).resize(_size962); + uint32_t _i966; + for (_i966 = 0; _i966 < _size962; ++_i966) { - xfer += iprot->readString((*(this->success))[_i956]); + xfer += iprot->readString((*(this->success))[_i966]); } 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 _size957; - ::apache::thrift::protocol::TType _etype960; - xfer += iprot->readListBegin(_etype960, _size957); - this->new_parts.resize(_size957); - uint32_t _i961; - for (_i961 = 0; _i961 < _size957; ++_i961) + uint32_t _size967; + ::apache::thrift::protocol::TType _etype970; + xfer += iprot->readListBegin(_etype970, _size967); + this->new_parts.resize(_size967); + uint32_t _i971; + for (_i971 = 0; _i971 < _size967; ++_i971) { - xfer += this->new_parts[_i961].read(iprot); + xfer += this->new_parts[_i971].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 _iter962; - for (_iter962 = this->new_parts.begin(); _iter962 != this->new_parts.end(); ++_iter962) + std::vector<Partition> ::const_iterator _iter972; + for (_iter972 = this->new_parts.begin(); _iter972 != this->new_parts.end(); ++_iter972) { - xfer += (*_iter962).write(oprot); + xfer += (*_iter972).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 _iter963; - for (_iter963 = (*(this->new_parts)).begin(); _iter963 != (*(this->new_parts)).end(); ++_iter963) + std::vector<Partition> ::const_iterator _iter973; + for (_iter973 = (*(this->new_parts)).begin(); _iter973 != (*(this->new_parts)).end(); ++_iter973) { - xfer += (*_iter963).write(oprot); + xfer += (*_iter973).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 _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->new_parts.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size974; + ::apache::thrift::protocol::TType _etype977; + xfer += iprot->readListBegin(_etype977, _size974); + this->new_parts.resize(_size974); + uint32_t _i978; + for (_i978 = 0; _i978 < _size974; ++_i978) { - xfer += this->new_parts[_i968].read(iprot); + xfer += this->new_parts[_i978].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 _iter969; - for (_iter969 = this->new_parts.begin(); _iter969 != this->new_parts.end(); ++_iter969) + std::vector<PartitionSpec> ::const_iterator _iter979; + for (_iter979 = this->new_parts.begin(); _iter979 != this->new_parts.end(); ++_iter979) { - xfer += (*_iter969).write(oprot); + xfer += (*_iter979).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 _iter970; - for (_iter970 = (*(this->new_parts)).begin(); _iter970 != (*(this->new_parts)).end(); ++_iter970) + std::vector<PartitionSpec> ::const_iterator _iter980; + for (_iter980 = (*(this->new_parts)).begin(); _iter980 != (*(this->new_parts)).end(); ++_iter980) { - xfer += (*_iter970).write(oprot); + xfer += (*_iter980).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 _size971; - ::apache::thrift::protocol::TType _etype974; - xfer += iprot->readListBegin(_etype974, _size971); - this->part_vals.resize(_size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size981; + ::apache::thrift::protocol::TType _etype984; + xfer += iprot->readListBegin(_etype984, _size981); + this->part_vals.resize(_size981); + uint32_t _i985; + for (_i985 = 0; _i985 < _size981; ++_i985) { - xfer += iprot->readString(this->part_vals[_i975]); + xfer += iprot->readString(this->part_vals[_i985]); } 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 _iter976; - for (_iter976 = this->part_vals.begin(); _iter976 != this->part_vals.end(); ++_iter976) + std::vector<std::string> ::const_iterator _iter986; + for (_iter986 = this->part_vals.begin(); _iter986 != this->part_vals.end(); ++_iter986) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter986)); } 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 _iter977; - for (_iter977 = (*(this->part_vals)).begin(); _iter977 != (*(this->part_vals)).end(); ++_iter977) + std::vector<std::string> ::const_iterator _iter987; + for (_iter987 = (*(this->part_vals)).begin(); _iter987 != (*(this->part_vals)).end(); ++_iter987) { - xfer += oprot->writeString((*_iter977)); + xfer += oprot->writeString((*_iter987)); } 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 _size978; - ::apache::thrift::protocol::TType _etype981; - xfer += iprot->readListBegin(_etype981, _size978); - this->part_vals.resize(_size978); - uint32_t _i982; - for (_i982 = 0; _i982 < _size978; ++_i982) + uint32_t _size988; + ::apache::thrift::protocol::TType _etype991; + xfer += iprot->readListBegin(_etype991, _size988); + this->part_vals.resize(_size988); + uint32_t _i992; + for (_i992 = 0; _i992 < _size988; ++_i992) { - xfer += iprot->readString(this->part_vals[_i982]); + xfer += iprot->readString(this->part_vals[_i992]); } 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 _iter983; - for (_iter983 = this->part_vals.begin(); _iter983 != this->part_vals.end(); ++_iter983) + std::vector<std::string> ::const_iterator _iter993; + for (_iter993 = this->part_vals.begin(); _iter993 != this->part_vals.end(); ++_iter993) { - xfer += oprot->writeString((*_iter983)); + xfer += oprot->writeString((*_iter993)); } 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 _iter984; - for (_iter984 = (*(this->part_vals)).begin(); _iter984 != (*(this->part_vals)).end(); ++_iter984) + std::vector<std::string> ::const_iterator _iter994; + for (_iter994 = (*(this->part_vals)).begin(); _iter994 != (*(this->part_vals)).end(); ++_iter994) { - xfer += oprot->writeString((*_iter984)); + xfer += oprot->writeString((*_iter994)); } 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 _size985; - ::apache::thrift::protocol::TType _etype988; - xfer += iprot->readListBegin(_etype988, _size985); - this->part_vals.resize(_size985); - uint32_t _i989; - for (_i989 = 0; _i989 < _size985; ++_i989) + uint32_t _size995; + ::apache::thrift::protocol::TType _etype998; + xfer += iprot->readListBegin(_etype998, _size995); + this->part_vals.resize(_size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - xfer += iprot->readString(this->part_vals[_i989]); + xfer += iprot->readString(this->part_vals[_i999]); } 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 _iter990; - for (_iter990 = this->part_vals.begin(); _iter990 != this->part_vals.end(); ++_iter990) + std::vector<std::string> ::const_iterator _iter1000; + for (_iter1000 = this->part_vals.begin(); _iter1000 != this->part_vals.end(); ++_iter1000) { - xfer += oprot->writeString((*_iter990)); + xfer += oprot->writeString((*_iter1000)); } 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 _iter991; - for (_iter991 = (*(this->part_vals)).begin(); _iter991 != (*(this->part_vals)).end(); ++_iter991) + std::vector<std::string> ::const_iterator _iter1001; + for (_iter1001 = (*(this->part_vals)).begin(); _iter1001 != (*(this->part_vals)).end(); ++_iter1001) { - xfer += oprot->writeString((*_iter991)); + xfer += oprot->writeString((*_iter1001)); } 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 _size992; - ::apache::thrift::protocol::TType _etype995; - xfer += iprot->readListBegin(_etype995, _size992); - this->part_vals.resize(_size992); - uint32_t _i996; - for (_i996 = 0; _i996 < _size992; ++_i996) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + this->part_vals.resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += iprot->readString(this->part_vals[_i996]); + xfer += iprot->readString(this->part_vals[_i1006]); } 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 _iter997; - for (_iter997 = this->part_vals.begin(); _iter997 != this->part_vals.end(); ++_iter997) + std::vector<std::string> ::const_iterator _iter1007; + for (_iter1007 = this->part_vals.begin(); _iter1007 != this->part_vals.end(); ++_iter1007) { - xfer += oprot->writeString((*_iter997)); + xfer += oprot->writeString((*_iter1007)); } 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 _iter998; - for (_iter998 = (*(this->part_vals)).begin(); _iter998 != (*(this->part_vals)).end(); ++_iter998) + std::vector<std::string> ::const_iterator _iter1008; + for (_iter1008 = (*(this->part_vals)).begin(); _iter1008 != (*(this->part_vals)).end(); ++_iter1008) { - xfer += oprot->writeString((*_iter998)); + xfer += oprot->writeString((*_iter1008)); } 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 _size999; - ::apache::thrift::protocol::TType _etype1002; - xfer += iprot->readListBegin(_etype1002, _size999); - this->part_vals.resize(_size999); - uint32_t _i1003; - for (_i1003 = 0; _i1003 < _size999; ++_i1003) + uint32_t _size1009; + ::apache::thrift::protocol::TType _etype1012; + xfer += iprot->readListBegin(_etype1012, _size1009); + this->part_vals.resize(_size1009); + uint32_t _i1013; + for (_i1013 = 0; _i1013 < _size1009; ++_i1013) { - xfer += iprot->readString(this->part_vals[_i1003]); + xfer += iprot->readString(this->part_vals[_i1013]); } 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 _iter1004; - for (_iter1004 = this->part_vals.begin(); _iter1004 != this->part_vals.end(); ++_iter1004) + std::vector<std::string> ::const_iterator _iter1014; + for (_iter1014 = this->part_vals.begin(); _iter1014 != this->part_vals.end(); ++_iter1014) { - xfer += oprot->writeString((*_iter1004)); + xfer += oprot->writeString((*_iter1014)); } 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 _iter1005; - for (_iter1005 = (*(this->part_vals)).begin(); _iter1005 != (*(this->part_vals)).end(); ++_iter1005) + std::vector<std::string> ::const_iterator _iter1015; + for (_iter1015 = (*(this->part_vals)).begin(); _iter1015 != (*(this->part_vals)).end(); ++_iter1015) { - xfer += oprot->writeString((*_iter1005)); + xfer += oprot->writeString((*_iter1015)); } 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 _size1006; - ::apache::thrift::protocol::TType _ktype1007; - ::apache::thrift::protocol::TType _vtype1008; - xfer += iprot->readMapBegin(_ktype1007, _vtype1008, _size1006); - uint32_t _i1010; - for (_i1010 = 0; _i1010 < _size1006; ++_i1010) + uint32_t _size1016; + ::apache::thrift::protocol::TType _ktype1017; + ::apache::thrift::protocol::TType _vtype1018; + xfer += iprot->readMapBegin(_ktype1017, _vtype1018, _size1016); + uint32_t _i1020; + for (_i1020 = 0; _i1020 < _size1016; ++_i1020) { - std::string _key1011; - xfer += iprot->readString(_key1011); - std::string& _val1012 = this->partitionSpecs[_key1011]; - xfer += iprot->readString(_val1012); + std::string _key1021; + xfer += iprot->readString(_key1021); + std::string& _val1022 = this->partitionSpecs[_key1021]; + xfer += iprot->readString(_val1022); } 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 _iter1013; - for (_iter1013 = this->partitionSpecs.begin(); _iter1013 != this->partitionSpecs.end(); ++_iter1013) + std::map<std::string, std::string> ::const_iterator _iter1023; + for (_iter1023 = this->partitionSpecs.begin(); _iter1023 != this->partitionSpecs.end(); ++_iter1023) { - xfer += oprot->writeString(_iter1013->first); - xfer += oprot->writeString(_iter1013->second); + xfer += oprot->writeString(_iter1023->first); + xfer += oprot->writeString(_iter1023->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 _iter1014; - for (_iter1014 = (*(this->partitionSpecs)).begin(); _iter1014 != (*(this->partitionSpecs)).end(); ++_iter1014) + std::map<std::string, std::string> ::const_iterator _iter1024; + for (_iter1024 = (*(this->partitionSpecs)).begin(); _iter1024 != (*(this->partitionSpecs)).end(); ++_iter1024) { - xfer += oprot->writeString(_iter1014->first); - xfer += oprot->writeString(_iter1014->second); + xfer += oprot->writeString(_iter1024->first); + xfer += oprot->writeString(_iter1024->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 _size1015; - ::apache::thrift::protocol::TType _ktype1016; - ::apache::thrift::protocol::TType _vtype1017; - xfer += iprot->readMapBegin(_ktype1016, _vtype1017, _size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1025; + ::apache::thrift::protocol::TType _ktype1026; + ::apache::thrift::protocol::TType _vtype1027; + xfer += iprot->readMapBegin(_ktype1026, _vtype1027, _size1025); + uint32_t _i1029; + for (_i1029 = 0; _i1029 < _size1025; ++_i1029) { - std::string _key1020; - xfer += iprot->readString(_key1020); - std::string& _val1021 = this->partitionSpecs[_key1020]; - xfer += iprot->readString(_val1021); + std::string _key1030; + xfer += iprot->readString(_key1030); + std::string& _val1031 = this->partitionSpecs[_key1030]; + xfer += iprot->readString(_val1031); } 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 _iter1022; - for (_iter1022 = this->partitionSpecs.begin(); _iter1022 != this->partitionSpecs.end(); ++_iter1022) + std::map<std::string, std::string> ::const_iterator _iter1032; + for (_iter1032 = this->partitionSpecs.begin(); _iter1032 != this->partitionSpecs.end(); ++_iter1032) { - xfer += oprot->writeString(_iter1022->first); - xfer += oprot->writeString(_iter1022->second); + xfer += oprot->writeString(_iter1032->first); + xfer += oprot->writeString(_iter1032->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 _iter1023; - for (_iter1023 = (*(this->partitionSpecs)).begin(); _iter1023 != (*(this->partitionSpecs)).end(); ++_iter1023) + std::map<std::string, std::string> ::const_iterator _iter1033; + for (_iter1033 = (*(this->partitionSpecs)).begin(); _iter1033 != (*(this->partitionSpecs)).end(); ++_iter1033) { - xfer += oprot->writeString(_iter1023->first); - xfer += oprot->writeString(_iter1023->second); + xfer += oprot->writeString(_iter1033->first); + xfer += oprot->writeString(_iter1033->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 _size1024; - ::apache::thrift::protocol::TType _etype1027; - xfer += iprot->readListBegin(_etype1027, _size1024); - this->success.resize(_size1024); - uint32_t _i1028; - for (_i1028 = 0; _i1028 < _size1024; ++_i1028) + uint32_t _size1034; + ::apache::thrift::protocol::TType _etype1037; + xfer += iprot->readListBegin(_etype1037, _size1034); + this->success.resize(_size1034); + uint32_t _i1038; + for (_i1038 = 0; _i1038 < _size1034; ++_i1038) { - xfer += this->success[_i1028].read(iprot); + xfer += this->success[_i1038].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 _iter1029; - for (_iter1029 = this->success.begin(); _iter1029 != this->success.end(); ++_iter1029) + std::vector<Partition> ::const_iterator _iter1039; + for (_iter1039 = this->success.begin(); _iter1039 != this->success.end(); ++_iter1039) { - xfer += (*_iter1029).write(oprot); + xfer += (*_iter1039).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 _size1030; - ::apache::thrift::protocol::TType _etype1033; - xfer += iprot->readListBegin(_etype1033, _size1030); - (*(this->success)).resize(_size1030); - uint32_t _i1034; - for (_i1034 = 0; _i1034 < _size1030; ++_i1034) + uint32_t _size1040; + ::apache::thrift::protocol::TType _etype1043; + xfer += iprot->readListBegin(_etype1043, _size1040); + (*(this->success)).resize(_size1040); + uint32_t _i1044; + for (_i1044 = 0; _i1044 < _size1040; ++_i1044) { - xfer += (*(this->success))[_i1034].read(iprot); + xfer += (*(this->success))[_i1044].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 _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 _size1045; + ::apache::thrift::protocol::TType _etype1048; + xfer += iprot->readListBegin(_etype1048, _size1045); + this->part_vals.resize(_size1045); + uint32_t _i1049; + for (_i1049 = 0; _i1049 < _size1045; ++_i1049) { - xfer += iprot->readString(this->part_vals[_i1039]); + xfer += iprot->readString(this->part_vals[_i1049]); } 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 _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 _size1050; + ::apache::thrift::protocol::TType _etype1053; + xfer += iprot->readListBegin(_etype1053, _size1050); + this->group_names.resize(_size1050); + uint32_t _i1054; + for (_i1054 = 0; _i1054 < _size1050; ++_i1054) { - xfer += iprot->readString(this->group_names[_i1044]); + xfer += iprot->readString(this->group_names[_i1054]); } 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 _iter1045; - for (_iter1045 = this->part_vals.begin(); _iter1045 != this->part_vals.end(); ++_iter1045) + std::vector<std::string> ::const_iterator _iter1055; + for (_iter1055 = this->part_vals.begin(); _iter1055 != this->part_vals.end(); ++_iter1055) { - xfer += oprot->writeString((*_iter1045)); + xfer += oprot->writeString((*_iter1055)); } 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 _iter1046; - for (_iter1046 = this->group_names.begin(); _iter1046 != this->group_names.end(); ++_iter1046) + std::vector<std::string> ::const_iterator _iter1056; + for (_iter1056 = this->group_names.begin(); _iter1056 != this->group_names.end(); ++_iter1056) { - xfer += oprot->writeString((*_iter1046)); + xfer += oprot->writeString((*_iter1056)); } 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 _iter1047; - for (_iter1047 = (*(this->part_vals)).begin(); _iter1047 != (*(this->part_vals)).end(); ++_iter1047) + std::vector<std::string> ::const_iterator _iter1057; + for (_iter1057 = (*(this->part_vals)).begin(); _iter1057 != (*(this->part_vals)).end(); ++_iter1057) { - xfer += oprot->writeString((*_iter1047)); + xfer += oprot->writeString((*_iter1057)); } 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 _iter1048; - for (_iter1048 = (*(this->group_names)).begin(); _iter1048 != (*(this->group_names)).end(); ++_iter1048) + std::vector<std::string> ::const_iterator _iter1058; + for (_iter1058 = (*(this->group_names)).begin(); _iter1058 != (*(this->group_names)).end(); ++_iter1058) { - xfer += oprot->writeString((*_iter1048)); + xfer += oprot->writeString((*_iter1058)); } 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 _size1049; - ::apache::thrift::protocol::TType _etype1052; - xfer += iprot->readListBegin(_etype1052, _size1049); - this->success.resize(_size1049); - uint32_t _i1053; - for (_i1053 = 0; _i1053 < _size1049; ++_i1053) + uint32_t _size1059; + ::apache::thrift::protocol::TType _etype1062; + xfer += iprot->readListBegin(_etype1062, _size1059); + this->success.resize(_size1059); + uint32_t _i1063; + for (_i1063 = 0; _i1063 < _size1059; ++_i1063) { - xfer += this->success[_i1053].read(iprot); + xfer += this->success[_i1063].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 _iter1054; - for (_iter1054 = this->success.begin(); _iter1054 != this->success.end(); ++_iter1054) + std::vector<Partition> ::const_iterator _iter1064; + for (_iter1064 = this->success.begin(); _iter1064 != this->success.end(); ++_iter1064) { - xfer += (*_iter1054).write(oprot); + xfer += (*_iter1064).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 _size1055; - ::apache::thrift::protocol::TType _etype1058; - xfer += iprot->readListBegin(_etype1058, _size1055); - (*(this->success)).resize(_size1055); - uint32_t _i1059; - for (_i1059 = 0; _i1059 < _size1055; ++_i1059) + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + (*(this->success)).resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) { - xfer += (*(this->success))[_i1059].read(iprot); + xfer += (*(this->success))[_i1069].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 _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->group_names.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1070; + ::apache::thrift::protocol::TType _etype1073; + xfer += iprot->readListBegin(_etype1073, _size1070); + this->group_names.resize(_size1070); + uint32_t _i1074; + for (_i1074 = 0; _i1074 < _size1070; ++_i1074) { - xfer += iprot->readString(this->group_names[_i1064]); + xfer += iprot->readString(this->group_names[_i1074]); } 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 _iter1065; - for (_iter1065 = this->group_names.begin(); _iter1065 != this->group_names.end(); ++_iter1065) + std::vector<std::string> ::const_iterator _iter1075; + for (_iter1075 = this->group_names.begin(); _iter1075 != this->group_names.end(); ++_iter1075) { - xfer += oprot->writeString((*_iter1065)); + xfer += oprot->writeString((*_iter1075)); } 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 _iter1066; - for (_iter1066 = (*(this->group_names)).begin(); _iter1066 != (*(this->group_names)).end(); ++_iter1066) + std::vector<std::string> ::const_iterator _iter1076; + for (_iter1076 = (*(this->group_names)).begin(); _iter1076 != (*(this->group_names)).end(); ++_iter1076) { - xfer += oprot->writeString((*_iter1066)); + xfer += oprot->writeString((*_iter1076)); } 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 _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 _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 += this->success[_i1071].read(iprot); + xfer += this->success[_i1081].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 _iter1072; - for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) + std::vector<Partition> ::const_iterator _iter1082; + for (_iter1082 = this->success.begin(); _iter1082 != this->success.end(); ++_iter1082) { - xfer += (*_iter1072).write(oprot); + xfer += (*_iter1082).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 _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 _size1083; + ::apache::thrift::protocol::TType _etype1086; + xfer += iprot->readListBegin(_etype1086, _size1083); + (*(this->success)).resize(_size1083); + uint32_t _i1087; + for (_i1087 = 0; _i1087 < _size1083; ++_i1087) { - xfer += (*(this->success))[_i1077].read(iprot); + xfer += (*(this->success))[_i1087].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 _size1078; - ::apache::thrift::protocol::TType _etype1081; - xfer += iprot->readListBegin(_etype1081, _size1078); - this->success.resize(_size1078); - uint32_t _i1082; - for (_i1082 = 0; _i1082 < _size1078; ++_i1082) + uint32_t _size1088; + ::apache::thrift::protocol::TType _etype1091; + xfer += iprot->readListBegin(_etype1091, _size1088); + this->success.resize(_size1088); + uint32_t _i1092; + for (_i1092 = 0; _i1092 < _size1088; ++_i1092) { - xfer += this->success[_i1082].read(iprot); + xfer += this->success[_i1092].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 _iter1083; - for (_iter1083 = this->success.begin(); _iter1083 != this->success.end(); ++_iter1083) + std::vector<PartitionSpec> ::const_iterator _iter1093; + for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) { - xfer += (*_iter1083).write(oprot); + xfer += (*_iter1093).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 _size1084; - ::apache::thrift::protocol::TType _etype1087; - xfer += iprot->readListBegin(_etype1087, _size1084); - (*(this->success)).resize(_size1084); - uint32_t _i1088; - for (_i1088 = 0; _i1088 < _size1084; ++_i1088) + uint32_t _size1094; + ::apache::thrift::protocol::TType _etype1097; + xfer += iprot->readListBegin(_etype1097, _size1094); + (*(this->success)).resize(_size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - xfer += (*(this->success))[_i1088].read(iprot); + xfer += (*(this->success))[_i1098].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 _size1089; - ::apache::thrift::protocol::TType _etype1092; - xfer += iprot->readListBegin(_etype1092, _size1089); - this->success.resize(_size1089); - uint32_t _i1093; - for (_i1093 = 0; _i1093 < _size1089; ++_i1093) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->success.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103)
<TRUNCATED>
