Modified: hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp URL: http://svn.apache.org/viewvc/hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1613335&r1=1613334&r2=1613335&view=diff ============================================================================== --- hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original) +++ hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Fri Jul 25 00:38:23 2014 @@ -736,14 +736,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size362; - ::apache::thrift::protocol::TType _etype365; - xfer += iprot->readListBegin(_etype365, _size362); - this->success.resize(_size362); - uint32_t _i366; - for (_i366 = 0; _i366 < _size362; ++_i366) + uint32_t _size363; + ::apache::thrift::protocol::TType _etype366; + xfer += iprot->readListBegin(_etype366, _size363); + this->success.resize(_size363); + uint32_t _i367; + for (_i367 = 0; _i367 < _size363; ++_i367) { - xfer += iprot->readString(this->success[_i366]); + xfer += iprot->readString(this->success[_i367]); } xfer += iprot->readListEnd(); } @@ -782,10 +782,10 @@ uint32_t ThriftHiveMetastore_get_databas 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 _iter367; - for (_iter367 = this->success.begin(); _iter367 != this->success.end(); ++_iter367) + std::vector<std::string> ::const_iterator _iter368; + for (_iter368 = this->success.begin(); _iter368 != this->success.end(); ++_iter368) { - xfer += oprot->writeString((*_iter367)); + xfer += oprot->writeString((*_iter368)); } xfer += oprot->writeListEnd(); } @@ -824,14 +824,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size368; - ::apache::thrift::protocol::TType _etype371; - xfer += iprot->readListBegin(_etype371, _size368); - (*(this->success)).resize(_size368); - uint32_t _i372; - for (_i372 = 0; _i372 < _size368; ++_i372) + uint32_t _size369; + ::apache::thrift::protocol::TType _etype372; + xfer += iprot->readListBegin(_etype372, _size369); + (*(this->success)).resize(_size369); + uint32_t _i373; + for (_i373 = 0; _i373 < _size369; ++_i373) { - xfer += iprot->readString((*(this->success))[_i372]); + xfer += iprot->readString((*(this->success))[_i373]); } xfer += iprot->readListEnd(); } @@ -929,14 +929,14 @@ uint32_t ThriftHiveMetastore_get_all_dat if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size373; - ::apache::thrift::protocol::TType _etype376; - xfer += iprot->readListBegin(_etype376, _size373); - this->success.resize(_size373); - uint32_t _i377; - for (_i377 = 0; _i377 < _size373; ++_i377) + uint32_t _size374; + ::apache::thrift::protocol::TType _etype377; + xfer += iprot->readListBegin(_etype377, _size374); + this->success.resize(_size374); + uint32_t _i378; + for (_i378 = 0; _i378 < _size374; ++_i378) { - xfer += iprot->readString(this->success[_i377]); + xfer += iprot->readString(this->success[_i378]); } xfer += iprot->readListEnd(); } @@ -975,10 +975,10 @@ uint32_t ThriftHiveMetastore_get_all_dat 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 _iter378; - for (_iter378 = this->success.begin(); _iter378 != this->success.end(); ++_iter378) + std::vector<std::string> ::const_iterator _iter379; + for (_iter379 = this->success.begin(); _iter379 != this->success.end(); ++_iter379) { - xfer += oprot->writeString((*_iter378)); + xfer += oprot->writeString((*_iter379)); } xfer += oprot->writeListEnd(); } @@ -1017,14 +1017,14 @@ uint32_t ThriftHiveMetastore_get_all_dat if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size379; - ::apache::thrift::protocol::TType _etype382; - xfer += iprot->readListBegin(_etype382, _size379); - (*(this->success)).resize(_size379); - uint32_t _i383; - for (_i383 = 0; _i383 < _size379; ++_i383) + uint32_t _size380; + ::apache::thrift::protocol::TType _etype383; + xfer += iprot->readListBegin(_etype383, _size380); + (*(this->success)).resize(_size380); + uint32_t _i384; + for (_i384 = 0; _i384 < _size380; ++_i384) { - xfer += iprot->readString((*(this->success))[_i383]); + xfer += iprot->readString((*(this->success))[_i384]); } xfer += iprot->readListEnd(); } @@ -1967,17 +1967,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size384; - ::apache::thrift::protocol::TType _ktype385; - ::apache::thrift::protocol::TType _vtype386; - xfer += iprot->readMapBegin(_ktype385, _vtype386, _size384); - uint32_t _i388; - for (_i388 = 0; _i388 < _size384; ++_i388) + uint32_t _size385; + ::apache::thrift::protocol::TType _ktype386; + ::apache::thrift::protocol::TType _vtype387; + xfer += iprot->readMapBegin(_ktype386, _vtype387, _size385); + uint32_t _i389; + for (_i389 = 0; _i389 < _size385; ++_i389) { - std::string _key389; - xfer += iprot->readString(_key389); - Type& _val390 = this->success[_key389]; - xfer += _val390.read(iprot); + std::string _key390; + xfer += iprot->readString(_key390); + Type& _val391 = this->success[_key390]; + xfer += _val391.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2016,11 +2016,11 @@ uint32_t ThriftHiveMetastore_get_type_al 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 _iter391; - for (_iter391 = this->success.begin(); _iter391 != this->success.end(); ++_iter391) + std::map<std::string, Type> ::const_iterator _iter392; + for (_iter392 = this->success.begin(); _iter392 != this->success.end(); ++_iter392) { - xfer += oprot->writeString(_iter391->first); - xfer += _iter391->second.write(oprot); + xfer += oprot->writeString(_iter392->first); + xfer += _iter392->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2059,17 +2059,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size392; - ::apache::thrift::protocol::TType _ktype393; - ::apache::thrift::protocol::TType _vtype394; - xfer += iprot->readMapBegin(_ktype393, _vtype394, _size392); - uint32_t _i396; - for (_i396 = 0; _i396 < _size392; ++_i396) + uint32_t _size393; + ::apache::thrift::protocol::TType _ktype394; + ::apache::thrift::protocol::TType _vtype395; + xfer += iprot->readMapBegin(_ktype394, _vtype395, _size393); + uint32_t _i397; + for (_i397 = 0; _i397 < _size393; ++_i397) { - std::string _key397; - xfer += iprot->readString(_key397); - Type& _val398 = (*(this->success))[_key397]; - xfer += _val398.read(iprot); + std::string _key398; + xfer += iprot->readString(_key398); + Type& _val399 = (*(this->success))[_key398]; + xfer += _val399.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2204,14 +2204,14 @@ uint32_t ThriftHiveMetastore_get_fields_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size399; - ::apache::thrift::protocol::TType _etype402; - xfer += iprot->readListBegin(_etype402, _size399); - this->success.resize(_size399); - uint32_t _i403; - for (_i403 = 0; _i403 < _size399; ++_i403) + uint32_t _size400; + ::apache::thrift::protocol::TType _etype403; + xfer += iprot->readListBegin(_etype403, _size400); + this->success.resize(_size400); + uint32_t _i404; + for (_i404 = 0; _i404 < _size400; ++_i404) { - xfer += this->success[_i403].read(iprot); + xfer += this->success[_i404].read(iprot); } xfer += iprot->readListEnd(); } @@ -2266,10 +2266,10 @@ uint32_t ThriftHiveMetastore_get_fields_ 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 _iter404; - for (_iter404 = this->success.begin(); _iter404 != this->success.end(); ++_iter404) + std::vector<FieldSchema> ::const_iterator _iter405; + for (_iter405 = this->success.begin(); _iter405 != this->success.end(); ++_iter405) { - xfer += (*_iter404).write(oprot); + xfer += (*_iter405).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2316,14 +2316,14 @@ uint32_t ThriftHiveMetastore_get_fields_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size405; - ::apache::thrift::protocol::TType _etype408; - xfer += iprot->readListBegin(_etype408, _size405); - (*(this->success)).resize(_size405); - uint32_t _i409; - for (_i409 = 0; _i409 < _size405; ++_i409) + uint32_t _size406; + ::apache::thrift::protocol::TType _etype409; + xfer += iprot->readListBegin(_etype409, _size406); + (*(this->success)).resize(_size406); + uint32_t _i410; + for (_i410 = 0; _i410 < _size406; ++_i410) { - xfer += (*(this->success))[_i409].read(iprot); + xfer += (*(this->success))[_i410].read(iprot); } xfer += iprot->readListEnd(); } @@ -2474,14 +2474,14 @@ uint32_t ThriftHiveMetastore_get_schema_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size410; - ::apache::thrift::protocol::TType _etype413; - xfer += iprot->readListBegin(_etype413, _size410); - this->success.resize(_size410); - uint32_t _i414; - for (_i414 = 0; _i414 < _size410; ++_i414) + uint32_t _size411; + ::apache::thrift::protocol::TType _etype414; + xfer += iprot->readListBegin(_etype414, _size411); + this->success.resize(_size411); + uint32_t _i415; + for (_i415 = 0; _i415 < _size411; ++_i415) { - xfer += this->success[_i414].read(iprot); + xfer += this->success[_i415].read(iprot); } xfer += iprot->readListEnd(); } @@ -2536,10 +2536,10 @@ uint32_t ThriftHiveMetastore_get_schema_ 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 _iter415; - for (_iter415 = this->success.begin(); _iter415 != this->success.end(); ++_iter415) + std::vector<FieldSchema> ::const_iterator _iter416; + for (_iter416 = this->success.begin(); _iter416 != this->success.end(); ++_iter416) { - xfer += (*_iter415).write(oprot); + xfer += (*_iter416).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2586,14 +2586,14 @@ uint32_t ThriftHiveMetastore_get_schema_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size416; - ::apache::thrift::protocol::TType _etype419; - xfer += iprot->readListBegin(_etype419, _size416); - (*(this->success)).resize(_size416); - uint32_t _i420; - for (_i420 = 0; _i420 < _size416; ++_i420) + uint32_t _size417; + ::apache::thrift::protocol::TType _etype420; + xfer += iprot->readListBegin(_etype420, _size417); + (*(this->success)).resize(_size417); + uint32_t _i421; + for (_i421 = 0; _i421 < _size417; ++_i421) { - xfer += (*(this->success))[_i420].read(iprot); + xfer += (*(this->success))[_i421].read(iprot); } xfer += iprot->readListEnd(); } @@ -3648,14 +3648,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size421; - ::apache::thrift::protocol::TType _etype424; - xfer += iprot->readListBegin(_etype424, _size421); - this->success.resize(_size421); - uint32_t _i425; - for (_i425 = 0; _i425 < _size421; ++_i425) + uint32_t _size422; + ::apache::thrift::protocol::TType _etype425; + xfer += iprot->readListBegin(_etype425, _size422); + this->success.resize(_size422); + uint32_t _i426; + for (_i426 = 0; _i426 < _size422; ++_i426) { - xfer += iprot->readString(this->success[_i425]); + xfer += iprot->readString(this->success[_i426]); } xfer += iprot->readListEnd(); } @@ -3694,10 +3694,10 @@ uint32_t ThriftHiveMetastore_get_tables_ 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 _iter426; - for (_iter426 = this->success.begin(); _iter426 != this->success.end(); ++_iter426) + std::vector<std::string> ::const_iterator _iter427; + for (_iter427 = this->success.begin(); _iter427 != this->success.end(); ++_iter427) { - xfer += oprot->writeString((*_iter426)); + xfer += oprot->writeString((*_iter427)); } xfer += oprot->writeListEnd(); } @@ -3736,14 +3736,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size427; - ::apache::thrift::protocol::TType _etype430; - xfer += iprot->readListBegin(_etype430, _size427); - (*(this->success)).resize(_size427); - uint32_t _i431; - for (_i431 = 0; _i431 < _size427; ++_i431) + uint32_t _size428; + ::apache::thrift::protocol::TType _etype431; + xfer += iprot->readListBegin(_etype431, _size428); + (*(this->success)).resize(_size428); + uint32_t _i432; + for (_i432 = 0; _i432 < _size428; ++_i432) { - xfer += iprot->readString((*(this->success))[_i431]); + xfer += iprot->readString((*(this->success))[_i432]); } xfer += iprot->readListEnd(); } @@ -3862,14 +3862,14 @@ uint32_t ThriftHiveMetastore_get_all_tab if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size432; - ::apache::thrift::protocol::TType _etype435; - xfer += iprot->readListBegin(_etype435, _size432); - this->success.resize(_size432); - uint32_t _i436; - for (_i436 = 0; _i436 < _size432; ++_i436) + uint32_t _size433; + ::apache::thrift::protocol::TType _etype436; + xfer += iprot->readListBegin(_etype436, _size433); + this->success.resize(_size433); + uint32_t _i437; + for (_i437 = 0; _i437 < _size433; ++_i437) { - xfer += iprot->readString(this->success[_i436]); + xfer += iprot->readString(this->success[_i437]); } xfer += iprot->readListEnd(); } @@ -3908,10 +3908,10 @@ uint32_t ThriftHiveMetastore_get_all_tab 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 _iter437; - for (_iter437 = this->success.begin(); _iter437 != this->success.end(); ++_iter437) + std::vector<std::string> ::const_iterator _iter438; + for (_iter438 = this->success.begin(); _iter438 != this->success.end(); ++_iter438) { - xfer += oprot->writeString((*_iter437)); + xfer += oprot->writeString((*_iter438)); } xfer += oprot->writeListEnd(); } @@ -3950,14 +3950,14 @@ uint32_t ThriftHiveMetastore_get_all_tab if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size438; - ::apache::thrift::protocol::TType _etype441; - xfer += iprot->readListBegin(_etype441, _size438); - (*(this->success)).resize(_size438); - uint32_t _i442; - for (_i442 = 0; _i442 < _size438; ++_i442) + uint32_t _size439; + ::apache::thrift::protocol::TType _etype442; + xfer += iprot->readListBegin(_etype442, _size439); + (*(this->success)).resize(_size439); + uint32_t _i443; + for (_i443 = 0; _i443 < _size439; ++_i443) { - xfer += iprot->readString((*(this->success))[_i442]); + xfer += iprot->readString((*(this->success))[_i443]); } xfer += iprot->readListEnd(); } @@ -4236,14 +4236,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size443; - ::apache::thrift::protocol::TType _etype446; - xfer += iprot->readListBegin(_etype446, _size443); - this->tbl_names.resize(_size443); - uint32_t _i447; - for (_i447 = 0; _i447 < _size443; ++_i447) + uint32_t _size444; + ::apache::thrift::protocol::TType _etype447; + xfer += iprot->readListBegin(_etype447, _size444); + this->tbl_names.resize(_size444); + uint32_t _i448; + for (_i448 = 0; _i448 < _size444; ++_i448) { - xfer += iprot->readString(this->tbl_names[_i447]); + xfer += iprot->readString(this->tbl_names[_i448]); } xfer += iprot->readListEnd(); } @@ -4275,10 +4275,10 @@ uint32_t ThriftHiveMetastore_get_table_o 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 _iter448; - for (_iter448 = this->tbl_names.begin(); _iter448 != this->tbl_names.end(); ++_iter448) + std::vector<std::string> ::const_iterator _iter449; + for (_iter449 = this->tbl_names.begin(); _iter449 != this->tbl_names.end(); ++_iter449) { - xfer += oprot->writeString((*_iter448)); + xfer += oprot->writeString((*_iter449)); } xfer += oprot->writeListEnd(); } @@ -4300,10 +4300,10 @@ uint32_t ThriftHiveMetastore_get_table_o 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 _iter449; - for (_iter449 = (*(this->tbl_names)).begin(); _iter449 != (*(this->tbl_names)).end(); ++_iter449) + std::vector<std::string> ::const_iterator _iter450; + for (_iter450 = (*(this->tbl_names)).begin(); _iter450 != (*(this->tbl_names)).end(); ++_iter450) { - xfer += oprot->writeString((*_iter449)); + xfer += oprot->writeString((*_iter450)); } xfer += oprot->writeListEnd(); } @@ -4338,14 +4338,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size450; - ::apache::thrift::protocol::TType _etype453; - xfer += iprot->readListBegin(_etype453, _size450); - this->success.resize(_size450); - uint32_t _i454; - for (_i454 = 0; _i454 < _size450; ++_i454) + uint32_t _size451; + ::apache::thrift::protocol::TType _etype454; + xfer += iprot->readListBegin(_etype454, _size451); + this->success.resize(_size451); + uint32_t _i455; + for (_i455 = 0; _i455 < _size451; ++_i455) { - xfer += this->success[_i454].read(iprot); + xfer += this->success[_i455].read(iprot); } xfer += iprot->readListEnd(); } @@ -4400,10 +4400,10 @@ uint32_t ThriftHiveMetastore_get_table_o 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 _iter455; - for (_iter455 = this->success.begin(); _iter455 != this->success.end(); ++_iter455) + std::vector<Table> ::const_iterator _iter456; + for (_iter456 = this->success.begin(); _iter456 != this->success.end(); ++_iter456) { - xfer += (*_iter455).write(oprot); + xfer += (*_iter456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4450,14 +4450,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size456; - ::apache::thrift::protocol::TType _etype459; - xfer += iprot->readListBegin(_etype459, _size456); - (*(this->success)).resize(_size456); - uint32_t _i460; - for (_i460 = 0; _i460 < _size456; ++_i460) + uint32_t _size457; + ::apache::thrift::protocol::TType _etype460; + xfer += iprot->readListBegin(_etype460, _size457); + (*(this->success)).resize(_size457); + uint32_t _i461; + for (_i461 = 0; _i461 < _size457; ++_i461) { - xfer += (*(this->success))[_i460].read(iprot); + xfer += (*(this->success))[_i461].read(iprot); } xfer += iprot->readListEnd(); } @@ -4624,14 +4624,14 @@ uint32_t ThriftHiveMetastore_get_table_n if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size461; - ::apache::thrift::protocol::TType _etype464; - xfer += iprot->readListBegin(_etype464, _size461); - this->success.resize(_size461); - uint32_t _i465; - for (_i465 = 0; _i465 < _size461; ++_i465) + uint32_t _size462; + ::apache::thrift::protocol::TType _etype465; + xfer += iprot->readListBegin(_etype465, _size462); + this->success.resize(_size462); + uint32_t _i466; + for (_i466 = 0; _i466 < _size462; ++_i466) { - xfer += iprot->readString(this->success[_i465]); + xfer += iprot->readString(this->success[_i466]); } xfer += iprot->readListEnd(); } @@ -4686,10 +4686,10 @@ uint32_t ThriftHiveMetastore_get_table_n 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 _iter466; - for (_iter466 = this->success.begin(); _iter466 != this->success.end(); ++_iter466) + std::vector<std::string> ::const_iterator _iter467; + for (_iter467 = this->success.begin(); _iter467 != this->success.end(); ++_iter467) { - xfer += oprot->writeString((*_iter466)); + xfer += oprot->writeString((*_iter467)); } xfer += oprot->writeListEnd(); } @@ -4736,14 +4736,14 @@ uint32_t ThriftHiveMetastore_get_table_n if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size467; - ::apache::thrift::protocol::TType _etype470; - xfer += iprot->readListBegin(_etype470, _size467); - (*(this->success)).resize(_size467); - uint32_t _i471; - for (_i471 = 0; _i471 < _size467; ++_i471) + uint32_t _size468; + ::apache::thrift::protocol::TType _etype471; + xfer += iprot->readListBegin(_etype471, _size468); + (*(this->success)).resize(_size468); + uint32_t _i472; + for (_i472 = 0; _i472 < _size468; ++_i472) { - xfer += iprot->readString((*(this->success))[_i471]); + xfer += iprot->readString((*(this->success))[_i472]); } xfer += iprot->readListEnd(); } @@ -5716,14 +5716,14 @@ uint32_t ThriftHiveMetastore_add_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size472; - ::apache::thrift::protocol::TType _etype475; - xfer += iprot->readListBegin(_etype475, _size472); - this->new_parts.resize(_size472); - uint32_t _i476; - for (_i476 = 0; _i476 < _size472; ++_i476) + uint32_t _size473; + ::apache::thrift::protocol::TType _etype476; + xfer += iprot->readListBegin(_etype476, _size473); + this->new_parts.resize(_size473); + uint32_t _i477; + for (_i477 = 0; _i477 < _size473; ++_i477) { - xfer += this->new_parts[_i476].read(iprot); + xfer += this->new_parts[_i477].read(iprot); } xfer += iprot->readListEnd(); } @@ -5751,10 +5751,10 @@ uint32_t ThriftHiveMetastore_add_partiti 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 _iter477; - for (_iter477 = this->new_parts.begin(); _iter477 != this->new_parts.end(); ++_iter477) + std::vector<Partition> ::const_iterator _iter478; + for (_iter478 = this->new_parts.begin(); _iter478 != this->new_parts.end(); ++_iter478) { - xfer += (*_iter477).write(oprot); + xfer += (*_iter478).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5772,10 +5772,10 @@ uint32_t ThriftHiveMetastore_add_partiti 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 _iter478; - for (_iter478 = (*(this->new_parts)).begin(); _iter478 != (*(this->new_parts)).end(); ++_iter478) + std::vector<Partition> ::const_iterator _iter479; + for (_iter479 = (*(this->new_parts)).begin(); _iter479 != (*(this->new_parts)).end(); ++_iter479) { - xfer += (*_iter478).write(oprot); + xfer += (*_iter479).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +5982,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size479; - ::apache::thrift::protocol::TType _etype482; - xfer += iprot->readListBegin(_etype482, _size479); - this->part_vals.resize(_size479); - uint32_t _i483; - for (_i483 = 0; _i483 < _size479; ++_i483) + uint32_t _size480; + ::apache::thrift::protocol::TType _etype483; + xfer += iprot->readListBegin(_etype483, _size480); + this->part_vals.resize(_size480); + uint32_t _i484; + for (_i484 = 0; _i484 < _size480; ++_i484) { - xfer += iprot->readString(this->part_vals[_i483]); + xfer += iprot->readString(this->part_vals[_i484]); } xfer += iprot->readListEnd(); } @@ -6025,10 +6025,10 @@ uint32_t ThriftHiveMetastore_append_part 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 _iter484; - for (_iter484 = this->part_vals.begin(); _iter484 != this->part_vals.end(); ++_iter484) + std::vector<std::string> ::const_iterator _iter485; + for (_iter485 = this->part_vals.begin(); _iter485 != this->part_vals.end(); ++_iter485) { - xfer += oprot->writeString((*_iter484)); + xfer += oprot->writeString((*_iter485)); } xfer += oprot->writeListEnd(); } @@ -6054,10 +6054,10 @@ uint32_t ThriftHiveMetastore_append_part 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 _iter485; - for (_iter485 = (*(this->part_vals)).begin(); _iter485 != (*(this->part_vals)).end(); ++_iter485) + std::vector<std::string> ::const_iterator _iter486; + for (_iter486 = (*(this->part_vals)).begin(); _iter486 != (*(this->part_vals)).end(); ++_iter486) { - xfer += oprot->writeString((*_iter485)); + xfer += oprot->writeString((*_iter486)); } xfer += oprot->writeListEnd(); } @@ -6486,14 +6486,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size486; - ::apache::thrift::protocol::TType _etype489; - xfer += iprot->readListBegin(_etype489, _size486); - this->part_vals.resize(_size486); - uint32_t _i490; - for (_i490 = 0; _i490 < _size486; ++_i490) + uint32_t _size487; + ::apache::thrift::protocol::TType _etype490; + xfer += iprot->readListBegin(_etype490, _size487); + this->part_vals.resize(_size487); + uint32_t _i491; + for (_i491 = 0; _i491 < _size487; ++_i491) { - xfer += iprot->readString(this->part_vals[_i490]); + xfer += iprot->readString(this->part_vals[_i491]); } xfer += iprot->readListEnd(); } @@ -6537,10 +6537,10 @@ uint32_t ThriftHiveMetastore_append_part 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 _iter491; - for (_iter491 = this->part_vals.begin(); _iter491 != this->part_vals.end(); ++_iter491) + std::vector<std::string> ::const_iterator _iter492; + for (_iter492 = this->part_vals.begin(); _iter492 != this->part_vals.end(); ++_iter492) { - xfer += oprot->writeString((*_iter491)); + xfer += oprot->writeString((*_iter492)); } xfer += oprot->writeListEnd(); } @@ -6570,10 +6570,10 @@ uint32_t ThriftHiveMetastore_append_part 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 _iter492; - for (_iter492 = (*(this->part_vals)).begin(); _iter492 != (*(this->part_vals)).end(); ++_iter492) + std::vector<std::string> ::const_iterator _iter493; + for (_iter493 = (*(this->part_vals)).begin(); _iter493 != (*(this->part_vals)).end(); ++_iter493) { - xfer += oprot->writeString((*_iter492)); + xfer += oprot->writeString((*_iter493)); } xfer += oprot->writeListEnd(); } @@ -7308,14 +7308,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size493; - ::apache::thrift::protocol::TType _etype496; - xfer += iprot->readListBegin(_etype496, _size493); - this->part_vals.resize(_size493); - uint32_t _i497; - for (_i497 = 0; _i497 < _size493; ++_i497) + uint32_t _size494; + ::apache::thrift::protocol::TType _etype497; + xfer += iprot->readListBegin(_etype497, _size494); + this->part_vals.resize(_size494); + uint32_t _i498; + for (_i498 = 0; _i498 < _size494; ++_i498) { - xfer += iprot->readString(this->part_vals[_i497]); + xfer += iprot->readString(this->part_vals[_i498]); } xfer += iprot->readListEnd(); } @@ -7359,10 +7359,10 @@ uint32_t ThriftHiveMetastore_drop_partit 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 _iter498; - for (_iter498 = this->part_vals.begin(); _iter498 != this->part_vals.end(); ++_iter498) + std::vector<std::string> ::const_iterator _iter499; + for (_iter499 = this->part_vals.begin(); _iter499 != this->part_vals.end(); ++_iter499) { - xfer += oprot->writeString((*_iter498)); + xfer += oprot->writeString((*_iter499)); } xfer += oprot->writeListEnd(); } @@ -7392,10 +7392,10 @@ uint32_t ThriftHiveMetastore_drop_partit 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 _iter499; - for (_iter499 = (*(this->part_vals)).begin(); _iter499 != (*(this->part_vals)).end(); ++_iter499) + std::vector<std::string> ::const_iterator _iter500; + for (_iter500 = (*(this->part_vals)).begin(); _iter500 != (*(this->part_vals)).end(); ++_iter500) { - xfer += oprot->writeString((*_iter499)); + xfer += oprot->writeString((*_iter500)); } xfer += oprot->writeListEnd(); } @@ -7586,14 +7586,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size500; - ::apache::thrift::protocol::TType _etype503; - xfer += iprot->readListBegin(_etype503, _size500); - this->part_vals.resize(_size500); - uint32_t _i504; - for (_i504 = 0; _i504 < _size500; ++_i504) + uint32_t _size501; + ::apache::thrift::protocol::TType _etype504; + xfer += iprot->readListBegin(_etype504, _size501); + this->part_vals.resize(_size501); + uint32_t _i505; + for (_i505 = 0; _i505 < _size501; ++_i505) { - xfer += iprot->readString(this->part_vals[_i504]); + xfer += iprot->readString(this->part_vals[_i505]); } xfer += iprot->readListEnd(); } @@ -7645,10 +7645,10 @@ uint32_t ThriftHiveMetastore_drop_partit 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 _iter505; - for (_iter505 = this->part_vals.begin(); _iter505 != this->part_vals.end(); ++_iter505) + std::vector<std::string> ::const_iterator _iter506; + for (_iter506 = this->part_vals.begin(); _iter506 != this->part_vals.end(); ++_iter506) { - xfer += oprot->writeString((*_iter505)); + xfer += oprot->writeString((*_iter506)); } xfer += oprot->writeListEnd(); } @@ -7682,10 +7682,10 @@ uint32_t ThriftHiveMetastore_drop_partit 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 _iter506; - for (_iter506 = (*(this->part_vals)).begin(); _iter506 != (*(this->part_vals)).end(); ++_iter506) + std::vector<std::string> ::const_iterator _iter507; + for (_iter507 = (*(this->part_vals)).begin(); _iter507 != (*(this->part_vals)).end(); ++_iter507) { - xfer += oprot->writeString((*_iter506)); + xfer += oprot->writeString((*_iter507)); } xfer += oprot->writeListEnd(); } @@ -8598,14 +8598,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size507; - ::apache::thrift::protocol::TType _etype510; - xfer += iprot->readListBegin(_etype510, _size507); - this->part_vals.resize(_size507); - uint32_t _i511; - for (_i511 = 0; _i511 < _size507; ++_i511) + uint32_t _size508; + ::apache::thrift::protocol::TType _etype511; + xfer += iprot->readListBegin(_etype511, _size508); + this->part_vals.resize(_size508); + uint32_t _i512; + for (_i512 = 0; _i512 < _size508; ++_i512) { - xfer += iprot->readString(this->part_vals[_i511]); + xfer += iprot->readString(this->part_vals[_i512]); } xfer += iprot->readListEnd(); } @@ -8641,10 +8641,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter512; - for (_iter512 = this->part_vals.begin(); _iter512 != this->part_vals.end(); ++_iter512) + std::vector<std::string> ::const_iterator _iter513; + for (_iter513 = this->part_vals.begin(); _iter513 != this->part_vals.end(); ++_iter513) { - xfer += oprot->writeString((*_iter512)); + xfer += oprot->writeString((*_iter513)); } xfer += oprot->writeListEnd(); } @@ -8670,10 +8670,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter513; - for (_iter513 = (*(this->part_vals)).begin(); _iter513 != (*(this->part_vals)).end(); ++_iter513) + std::vector<std::string> ::const_iterator _iter514; + for (_iter514 = (*(this->part_vals)).begin(); _iter514 != (*(this->part_vals)).end(); ++_iter514) { - xfer += oprot->writeString((*_iter513)); + xfer += oprot->writeString((*_iter514)); } xfer += oprot->writeListEnd(); } @@ -8844,17 +8844,17 @@ uint32_t ThriftHiveMetastore_exchange_pa if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size514; - ::apache::thrift::protocol::TType _ktype515; - ::apache::thrift::protocol::TType _vtype516; - xfer += iprot->readMapBegin(_ktype515, _vtype516, _size514); - uint32_t _i518; - for (_i518 = 0; _i518 < _size514; ++_i518) + uint32_t _size515; + ::apache::thrift::protocol::TType _ktype516; + ::apache::thrift::protocol::TType _vtype517; + xfer += iprot->readMapBegin(_ktype516, _vtype517, _size515); + uint32_t _i519; + for (_i519 = 0; _i519 < _size515; ++_i519) { - std::string _key519; - xfer += iprot->readString(_key519); - std::string& _val520 = this->partitionSpecs[_key519]; - xfer += iprot->readString(_val520); + std::string _key520; + xfer += iprot->readString(_key520); + std::string& _val521 = this->partitionSpecs[_key520]; + xfer += iprot->readString(_val521); } xfer += iprot->readMapEnd(); } @@ -8914,11 +8914,11 @@ uint32_t ThriftHiveMetastore_exchange_pa 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 _iter521; - for (_iter521 = this->partitionSpecs.begin(); _iter521 != this->partitionSpecs.end(); ++_iter521) + std::map<std::string, std::string> ::const_iterator _iter522; + for (_iter522 = this->partitionSpecs.begin(); _iter522 != this->partitionSpecs.end(); ++_iter522) { - xfer += oprot->writeString(_iter521->first); - xfer += oprot->writeString(_iter521->second); + xfer += oprot->writeString(_iter522->first); + xfer += oprot->writeString(_iter522->second); } xfer += oprot->writeMapEnd(); } @@ -8952,11 +8952,11 @@ uint32_t ThriftHiveMetastore_exchange_pa 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 _iter522; - for (_iter522 = (*(this->partitionSpecs)).begin(); _iter522 != (*(this->partitionSpecs)).end(); ++_iter522) + std::map<std::string, std::string> ::const_iterator _iter523; + for (_iter523 = (*(this->partitionSpecs)).begin(); _iter523 != (*(this->partitionSpecs)).end(); ++_iter523) { - xfer += oprot->writeString(_iter522->first); - xfer += oprot->writeString(_iter522->second); + xfer += oprot->writeString(_iter523->first); + xfer += oprot->writeString(_iter523->second); } xfer += oprot->writeMapEnd(); } @@ -9199,14 +9199,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size523; - ::apache::thrift::protocol::TType _etype526; - xfer += iprot->readListBegin(_etype526, _size523); - this->part_vals.resize(_size523); - uint32_t _i527; - for (_i527 = 0; _i527 < _size523; ++_i527) + uint32_t _size524; + ::apache::thrift::protocol::TType _etype527; + xfer += iprot->readListBegin(_etype527, _size524); + this->part_vals.resize(_size524); + uint32_t _i528; + for (_i528 = 0; _i528 < _size524; ++_i528) { - xfer += iprot->readString(this->part_vals[_i527]); + xfer += iprot->readString(this->part_vals[_i528]); } xfer += iprot->readListEnd(); } @@ -9227,14 +9227,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size528; - ::apache::thrift::protocol::TType _etype531; - xfer += iprot->readListBegin(_etype531, _size528); - this->group_names.resize(_size528); - uint32_t _i532; - for (_i532 = 0; _i532 < _size528; ++_i532) + uint32_t _size529; + ::apache::thrift::protocol::TType _etype532; + xfer += iprot->readListBegin(_etype532, _size529); + this->group_names.resize(_size529); + uint32_t _i533; + for (_i533 = 0; _i533 < _size529; ++_i533) { - xfer += iprot->readString(this->group_names[_i532]); + xfer += iprot->readString(this->group_names[_i533]); } xfer += iprot->readListEnd(); } @@ -9270,10 +9270,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter533; - for (_iter533 = this->part_vals.begin(); _iter533 != this->part_vals.end(); ++_iter533) + std::vector<std::string> ::const_iterator _iter534; + for (_iter534 = this->part_vals.begin(); _iter534 != this->part_vals.end(); ++_iter534) { - xfer += oprot->writeString((*_iter533)); + xfer += oprot->writeString((*_iter534)); } xfer += oprot->writeListEnd(); } @@ -9286,10 +9286,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter534; - for (_iter534 = this->group_names.begin(); _iter534 != this->group_names.end(); ++_iter534) + std::vector<std::string> ::const_iterator _iter535; + for (_iter535 = this->group_names.begin(); _iter535 != this->group_names.end(); ++_iter535) { - xfer += oprot->writeString((*_iter534)); + xfer += oprot->writeString((*_iter535)); } xfer += oprot->writeListEnd(); } @@ -9315,10 +9315,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter535; - for (_iter535 = (*(this->part_vals)).begin(); _iter535 != (*(this->part_vals)).end(); ++_iter535) + std::vector<std::string> ::const_iterator _iter536; + for (_iter536 = (*(this->part_vals)).begin(); _iter536 != (*(this->part_vals)).end(); ++_iter536) { - xfer += oprot->writeString((*_iter535)); + xfer += oprot->writeString((*_iter536)); } xfer += oprot->writeListEnd(); } @@ -9331,10 +9331,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter536; - for (_iter536 = (*(this->group_names)).begin(); _iter536 != (*(this->group_names)).end(); ++_iter536) + std::vector<std::string> ::const_iterator _iter537; + for (_iter537 = (*(this->group_names)).begin(); _iter537 != (*(this->group_names)).end(); ++_iter537) { - xfer += oprot->writeString((*_iter536)); + xfer += oprot->writeString((*_iter537)); } xfer += oprot->writeListEnd(); } @@ -9837,14 +9837,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size537; - ::apache::thrift::protocol::TType _etype540; - xfer += iprot->readListBegin(_etype540, _size537); - this->success.resize(_size537); - uint32_t _i541; - for (_i541 = 0; _i541 < _size537; ++_i541) + uint32_t _size538; + ::apache::thrift::protocol::TType _etype541; + xfer += iprot->readListBegin(_etype541, _size538); + this->success.resize(_size538); + uint32_t _i542; + for (_i542 = 0; _i542 < _size538; ++_i542) { - xfer += this->success[_i541].read(iprot); + xfer += this->success[_i542].read(iprot); } xfer += iprot->readListEnd(); } @@ -9891,10 +9891,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter542; - for (_iter542 = this->success.begin(); _iter542 != this->success.end(); ++_iter542) + std::vector<Partition> ::const_iterator _iter543; + for (_iter543 = this->success.begin(); _iter543 != this->success.end(); ++_iter543) { - xfer += (*_iter542).write(oprot); + xfer += (*_iter543).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9937,14 +9937,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size543; - ::apache::thrift::protocol::TType _etype546; - xfer += iprot->readListBegin(_etype546, _size543); - (*(this->success)).resize(_size543); - uint32_t _i547; - for (_i547 = 0; _i547 < _size543; ++_i547) + uint32_t _size544; + ::apache::thrift::protocol::TType _etype547; + xfer += iprot->readListBegin(_etype547, _size544); + (*(this->success)).resize(_size544); + uint32_t _i548; + for (_i548 = 0; _i548 < _size544; ++_i548) { - xfer += (*(this->success))[_i547].read(iprot); + xfer += (*(this->success))[_i548].read(iprot); } xfer += iprot->readListEnd(); } @@ -10037,14 +10037,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size548; - ::apache::thrift::protocol::TType _etype551; - xfer += iprot->readListBegin(_etype551, _size548); - this->group_names.resize(_size548); - uint32_t _i552; - for (_i552 = 0; _i552 < _size548; ++_i552) + uint32_t _size549; + ::apache::thrift::protocol::TType _etype552; + xfer += iprot->readListBegin(_etype552, _size549); + this->group_names.resize(_size549); + uint32_t _i553; + for (_i553 = 0; _i553 < _size549; ++_i553) { - xfer += iprot->readString(this->group_names[_i552]); + xfer += iprot->readString(this->group_names[_i553]); } xfer += iprot->readListEnd(); } @@ -10088,10 +10088,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter553; - for (_iter553 = this->group_names.begin(); _iter553 != this->group_names.end(); ++_iter553) + std::vector<std::string> ::const_iterator _iter554; + for (_iter554 = this->group_names.begin(); _iter554 != this->group_names.end(); ++_iter554) { - xfer += oprot->writeString((*_iter553)); + xfer += oprot->writeString((*_iter554)); } xfer += oprot->writeListEnd(); } @@ -10125,10 +10125,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter554; - for (_iter554 = (*(this->group_names)).begin(); _iter554 != (*(this->group_names)).end(); ++_iter554) + std::vector<std::string> ::const_iterator _iter555; + for (_iter555 = (*(this->group_names)).begin(); _iter555 != (*(this->group_names)).end(); ++_iter555) { - xfer += oprot->writeString((*_iter554)); + xfer += oprot->writeString((*_iter555)); } xfer += oprot->writeListEnd(); } @@ -10163,14 +10163,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size555; - ::apache::thrift::protocol::TType _etype558; - xfer += iprot->readListBegin(_etype558, _size555); - this->success.resize(_size555); - uint32_t _i559; - for (_i559 = 0; _i559 < _size555; ++_i559) + uint32_t _size556; + ::apache::thrift::protocol::TType _etype559; + xfer += iprot->readListBegin(_etype559, _size556); + this->success.resize(_size556); + uint32_t _i560; + for (_i560 = 0; _i560 < _size556; ++_i560) { - xfer += this->success[_i559].read(iprot); + xfer += this->success[_i560].read(iprot); } xfer += iprot->readListEnd(); } @@ -10217,10 +10217,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter560; - for (_iter560 = this->success.begin(); _iter560 != this->success.end(); ++_iter560) + std::vector<Partition> ::const_iterator _iter561; + for (_iter561 = this->success.begin(); _iter561 != this->success.end(); ++_iter561) { - xfer += (*_iter560).write(oprot); + xfer += (*_iter561).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10263,14 +10263,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size561; - ::apache::thrift::protocol::TType _etype564; - xfer += iprot->readListBegin(_etype564, _size561); - (*(this->success)).resize(_size561); - uint32_t _i565; - for (_i565 = 0; _i565 < _size561; ++_i565) + uint32_t _size562; + ::apache::thrift::protocol::TType _etype565; + xfer += iprot->readListBegin(_etype565, _size562); + (*(this->success)).resize(_size562); + uint32_t _i566; + for (_i566 = 0; _i566 < _size562; ++_i566) { - xfer += (*(this->success))[_i565].read(iprot); + xfer += (*(this->success))[_i566].read(iprot); } xfer += iprot->readListEnd(); } @@ -10429,14 +10429,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size566; - ::apache::thrift::protocol::TType _etype569; - xfer += iprot->readListBegin(_etype569, _size566); - this->success.resize(_size566); - uint32_t _i570; - for (_i570 = 0; _i570 < _size566; ++_i570) + uint32_t _size567; + ::apache::thrift::protocol::TType _etype570; + xfer += iprot->readListBegin(_etype570, _size567); + this->success.resize(_size567); + uint32_t _i571; + for (_i571 = 0; _i571 < _size567; ++_i571) { - xfer += iprot->readString(this->success[_i570]); + xfer += iprot->readString(this->success[_i571]); } xfer += iprot->readListEnd(); } @@ -10475,10 +10475,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter571; - for (_iter571 = this->success.begin(); _iter571 != this->success.end(); ++_iter571) + std::vector<std::string> ::const_iterator _iter572; + for (_iter572 = this->success.begin(); _iter572 != this->success.end(); ++_iter572) { - xfer += oprot->writeString((*_iter571)); + xfer += oprot->writeString((*_iter572)); } xfer += oprot->writeListEnd(); } @@ -10517,14 +10517,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size572; - ::apache::thrift::protocol::TType _etype575; - xfer += iprot->readListBegin(_etype575, _size572); - (*(this->success)).resize(_size572); - uint32_t _i576; - for (_i576 = 0; _i576 < _size572; ++_i576) + uint32_t _size573; + ::apache::thrift::protocol::TType _etype576; + xfer += iprot->readListBegin(_etype576, _size573); + (*(this->success)).resize(_size573); + uint32_t _i577; + for (_i577 = 0; _i577 < _size573; ++_i577) { - xfer += iprot->readString((*(this->success))[_i576]); + xfer += iprot->readString((*(this->success))[_i577]); } xfer += iprot->readListEnd(); } @@ -10593,14 +10593,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size577; - ::apache::thrift::protocol::TType _etype580; - xfer += iprot->readListBegin(_etype580, _size577); - this->part_vals.resize(_size577); - uint32_t _i581; - for (_i581 = 0; _i581 < _size577; ++_i581) + uint32_t _size578; + ::apache::thrift::protocol::TType _etype581; + xfer += iprot->readListBegin(_etype581, _size578); + this->part_vals.resize(_size578); + uint32_t _i582; + for (_i582 = 0; _i582 < _size578; ++_i582) { - xfer += iprot->readString(this->part_vals[_i581]); + xfer += iprot->readString(this->part_vals[_i582]); } xfer += iprot->readListEnd(); } @@ -10644,10 +10644,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter582; - for (_iter582 = this->part_vals.begin(); _iter582 != this->part_vals.end(); ++_iter582) + std::vector<std::string> ::const_iterator _iter583; + for (_iter583 = this->part_vals.begin(); _iter583 != this->part_vals.end(); ++_iter583) { - xfer += oprot->writeString((*_iter582)); + xfer += oprot->writeString((*_iter583)); } xfer += oprot->writeListEnd(); } @@ -10677,10 +10677,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter583; - for (_iter583 = (*(this->part_vals)).begin(); _iter583 != (*(this->part_vals)).end(); ++_iter583) + std::vector<std::string> ::const_iterator _iter584; + for (_iter584 = (*(this->part_vals)).begin(); _iter584 != (*(this->part_vals)).end(); ++_iter584) { - xfer += oprot->writeString((*_iter583)); + xfer += oprot->writeString((*_iter584)); } xfer += oprot->writeListEnd(); } @@ -10719,14 +10719,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size584; - ::apache::thrift::protocol::TType _etype587; - xfer += iprot->readListBegin(_etype587, _size584); - this->success.resize(_size584); - uint32_t _i588; - for (_i588 = 0; _i588 < _size584; ++_i588) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readListBegin(_etype588, _size585); + this->success.resize(_size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - xfer += this->success[_i588].read(iprot); + xfer += this->success[_i589].read(iprot); } xfer += iprot->readListEnd(); } @@ -10773,10 +10773,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter589; - for (_iter589 = this->success.begin(); _iter589 != this->success.end(); ++_iter589) + std::vector<Partition> ::const_iterator _iter590; + for (_iter590 = this->success.begin(); _iter590 != this->success.end(); ++_iter590) { - xfer += (*_iter589).write(oprot); + xfer += (*_iter590).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10819,14 +10819,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size590; - ::apache::thrift::protocol::TType _etype593; - xfer += iprot->readListBegin(_etype593, _size590); - (*(this->success)).resize(_size590); - uint32_t _i594; - for (_i594 = 0; _i594 < _size590; ++_i594) + uint32_t _size591; + ::apache::thrift::protocol::TType _etype594; + xfer += iprot->readListBegin(_etype594, _size591); + (*(this->success)).resize(_size591); + uint32_t _i595; + for (_i595 = 0; _i595 < _size591; ++_i595) { - xfer += (*(this->success))[_i594].read(iprot); + xfer += (*(this->success))[_i595].read(iprot); } xfer += iprot->readListEnd(); } @@ -10903,14 +10903,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size595; - ::apache::thrift::protocol::TType _etype598; - xfer += iprot->readListBegin(_etype598, _size595); - this->part_vals.resize(_size595); - uint32_t _i599; - for (_i599 = 0; _i599 < _size595; ++_i599) + uint32_t _size596; + ::apache::thrift::protocol::TType _etype599; + xfer += iprot->readListBegin(_etype599, _size596); + this->part_vals.resize(_size596); + uint32_t _i600; + for (_i600 = 0; _i600 < _size596; ++_i600) { - xfer += iprot->readString(this->part_vals[_i599]); + xfer += iprot->readString(this->part_vals[_i600]); } xfer += iprot->readListEnd(); } @@ -10939,14 +10939,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size600; - ::apache::thrift::protocol::TType _etype603; - xfer += iprot->readListBegin(_etype603, _size600); - this->group_names.resize(_size600); - uint32_t _i604; - for (_i604 = 0; _i604 < _size600; ++_i604) + uint32_t _size601; + ::apache::thrift::protocol::TType _etype604; + xfer += iprot->readListBegin(_etype604, _size601); + this->group_names.resize(_size601); + uint32_t _i605; + for (_i605 = 0; _i605 < _size601; ++_i605) { - xfer += iprot->readString(this->group_names[_i604]); + xfer += iprot->readString(this->group_names[_i605]); } xfer += iprot->readListEnd(); } @@ -10982,10 +10982,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter605; - for (_iter605 = this->part_vals.begin(); _iter605 != this->part_vals.end(); ++_iter605) + std::vector<std::string> ::const_iterator _iter606; + for (_iter606 = this->part_vals.begin(); _iter606 != this->part_vals.end(); ++_iter606) { - xfer += oprot->writeString((*_iter605)); + xfer += oprot->writeString((*_iter606)); } xfer += oprot->writeListEnd(); } @@ -11002,10 +11002,10 @@ uint32_t ThriftHiveMetastore_get_partiti xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter606; - for (_iter606 = this->group_names.begin(); _iter606 != this->group_names.end(); ++_iter606) + std::vector<std::string> ::const_iterator _iter607; + for (_iter607 = this->group_names.begin(); _iter607 != this->group_names.end(); ++_iter607) { - xfer += oprot->writeString((*_iter606)); + xfer += oprot->writeString((*_iter607)); } xfer += oprot->writeListEnd(); } @@ -11031,10 +11031,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter607; - for (_iter607 = (*(this->part_vals)).begin(); _iter607 != (*(this->part_vals)).end(); ++_iter607) + std::vector<std::string> ::const_iterator _iter608; + for (_iter608 = (*(this->part_vals)).begin(); _iter608 != (*(this->part_vals)).end(); ++_iter608) { - xfer += oprot->writeString((*_iter607)); + xfer += oprot->writeString((*_iter608)); } xfer += oprot->writeListEnd(); } @@ -11051,10 +11051,10 @@ uint32_t ThriftHiveMetastore_get_partiti xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter608; - for (_iter608 = (*(this->group_names)).begin(); _iter608 != (*(this->group_names)).end(); ++_iter608) + std::vector<std::string> ::const_iterator _iter609; + for (_iter609 = (*(this->group_names)).begin(); _iter609 != (*(this->group_names)).end(); ++_iter609) { - xfer += oprot->writeString((*_iter608)); + xfer += oprot->writeString((*_iter609)); } xfer += oprot->writeListEnd(); } @@ -11089,14 +11089,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size609; - ::apache::thrift::protocol::TType _etype612; - xfer += iprot->readListBegin(_etype612, _size609); - this->success.resize(_size609); - uint32_t _i613; - for (_i613 = 0; _i613 < _size609; ++_i613) + uint32_t _size610; + ::apache::thrift::protocol::TType _etype613; + xfer += iprot->readListBegin(_etype613, _size610); + this->success.resize(_size610); + uint32_t _i614; + for (_i614 = 0; _i614 < _size610; ++_i614) { - xfer += this->success[_i613].read(iprot); + xfer += this->success[_i614].read(iprot); } xfer += iprot->readListEnd(); } @@ -11143,10 +11143,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter614; - for (_iter614 = this->success.begin(); _iter614 != this->success.end(); ++_iter614) + std::vector<Partition> ::const_iterator _iter615; + for (_iter615 = this->success.begin(); _iter615 != this->success.end(); ++_iter615) { - xfer += (*_iter614).write(oprot); + xfer += (*_iter615).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11189,14 +11189,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size615; - ::apache::thrift::protocol::TType _etype618; - xfer += iprot->readListBegin(_etype618, _size615); - (*(this->success)).resize(_size615); - uint32_t _i619; - for (_i619 = 0; _i619 < _size615; ++_i619) + uint32_t _size616; + ::apache::thrift::protocol::TType _etype619; + xfer += iprot->readListBegin(_etype619, _size616); + (*(this->success)).resize(_size616); + uint32_t _i620; + for (_i620 = 0; _i620 < _size616; ++_i620) { - xfer += (*(this->success))[_i619].read(iprot); + xfer += (*(this->success))[_i620].read(iprot); } xfer += iprot->readListEnd(); } @@ -11273,14 +11273,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size620; - ::apache::thrift::protocol::TType _etype623; - xfer += iprot->readListBegin(_etype623, _size620); - this->part_vals.resize(_size620); - uint32_t _i624; - for (_i624 = 0; _i624 < _size620; ++_i624) + uint32_t _size621; + ::apache::thrift::protocol::TType _etype624; + xfer += iprot->readListBegin(_etype624, _size621); + this->part_vals.resize(_size621); + uint32_t _i625; + for (_i625 = 0; _i625 < _size621; ++_i625) { - xfer += iprot->readString(this->part_vals[_i624]); + xfer += iprot->readString(this->part_vals[_i625]); } xfer += iprot->readListEnd(); } @@ -11324,10 +11324,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter625; - for (_iter625 = this->part_vals.begin(); _iter625 != this->part_vals.end(); ++_iter625) + std::vector<std::string> ::const_iterator _iter626; + for (_iter626 = this->part_vals.begin(); _iter626 != this->part_vals.end(); ++_iter626) { - xfer += oprot->writeString((*_iter625)); + xfer += oprot->writeString((*_iter626)); } xfer += oprot->writeListEnd(); } @@ -11357,10 +11357,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter626; - for (_iter626 = (*(this->part_vals)).begin(); _iter626 != (*(this->part_vals)).end(); ++_iter626) + std::vector<std::string> ::const_iterator _iter627; + for (_iter627 = (*(this->part_vals)).begin(); _iter627 != (*(this->part_vals)).end(); ++_iter627) { - xfer += oprot->writeString((*_iter626)); + xfer += oprot->writeString((*_iter627)); } xfer += oprot->writeListEnd(); } @@ -11399,14 +11399,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size627; - ::apache::thrift::protocol::TType _etype630; - xfer += iprot->readListBegin(_etype630, _size627); - this->success.resize(_size627); - uint32_t _i631; - for (_i631 = 0; _i631 < _size627; ++_i631) + uint32_t _size628; + ::apache::thrift::protocol::TType _etype631; + xfer += iprot->readListBegin(_etype631, _size628); + this->success.resize(_size628); + uint32_t _i632; + for (_i632 = 0; _i632 < _size628; ++_i632) { - xfer += iprot->readString(this->success[_i631]); + xfer += iprot->readString(this->success[_i632]); } xfer += iprot->readListEnd(); } @@ -11453,10 +11453,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter632; - for (_iter632 = this->success.begin(); _iter632 != this->success.end(); ++_iter632) + std::vector<std::string> ::const_iterator _iter633; + for (_iter633 = this->success.begin(); _iter633 != this->success.end(); ++_iter633) { - xfer += oprot->writeString((*_iter632)); + xfer += oprot->writeString((*_iter633)); } xfer += oprot->writeListEnd(); } @@ -11499,14 +11499,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size633; - ::apache::thrift::protocol::TType _etype636; - xfer += iprot->readListBegin(_etype636, _size633); - (*(this->success)).resize(_size633); - uint32_t _i637; - for (_i637 = 0; _i637 < _size633; ++_i637) + uint32_t _size634; + ::apache::thrift::protocol::TType _etype637; + xfer += iprot->readListBegin(_etype637, _size634); + (*(this->success)).resize(_size634); + uint32_t _i638; + for (_i638 = 0; _i638 < _size634; ++_i638) { - xfer += iprot->readString((*(this->success))[_i637]); + xfer += iprot->readString((*(this->success))[_i638]); } xfer += iprot->readListEnd(); } @@ -11681,14 +11681,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size638; - ::apache::thrift::protocol::TType _etype641; - xfer += iprot->readListBegin(_etype641, _size638); - this->success.resize(_size638); - uint32_t _i642; - for (_i642 = 0; _i642 < _size638; ++_i642) + uint32_t _size639; + ::apache::thrift::protocol::TType _etype642; + xfer += iprot->readListBegin(_etype642, _size639); + this->success.resize(_size639); + uint32_t _i643; + for (_i643 = 0; _i643 < _size639; ++_i643) { - xfer += this->success[_i642].read(iprot); + xfer += this->success[_i643].read(iprot); } xfer += iprot->readListEnd(); } @@ -11735,10 +11735,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter643; - for (_iter643 = this->success.begin(); _iter643 != this->success.end(); ++_iter643) + std::vector<Partition> ::const_iterator _iter644; + for (_iter644 = this->success.begin(); _iter644 != this->success.end(); ++_iter644) { - xfer += (*_iter643).write(oprot); + xfer += (*_iter644).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11781,14 +11781,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size644; - ::apache::thrift::protocol::TType _etype647; - xfer += iprot->readListBegin(_etype647, _size644); - (*(this->success)).resize(_size644); - uint32_t _i648; - for (_i648 = 0; _i648 < _size644; ++_i648) + uint32_t _size645; + ::apache::thrift::protocol::TType _etype648; + xfer += iprot->readListBegin(_etype648, _size645); + (*(this->success)).resize(_size645); + uint32_t _i649; + for (_i649 = 0; _i649 < _size645; ++_i649) { - xfer += (*(this->success))[_i648].read(iprot); + xfer += (*(this->success))[_i649].read(iprot); } xfer += iprot->readListEnd(); } @@ -12067,14 +12067,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->names.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + uint32_t _size650; + ::apache::thrift::protocol::TType _etype653; + xfer += iprot->readListBegin(_etype653, _size650); + this->names.resize(_size650); + uint32_t _i654; + for (_i654 = 0; _i654 < _size650; ++_i654) { - xfer += iprot->readString(this->names[_i653]); + xfer += iprot->readString(this->names[_i654]); } xfer += iprot->readListEnd(); } @@ -12110,10 +12110,10 @@ uint32_t ThriftHiveMetastore_get_partiti xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size())); - std::vector<std::string> ::const_iterator _iter654; - for (_iter654 = this->names.begin(); _iter654 != this->names.end(); ++_iter654) + std::vector<std::string> ::const_iterator _iter655; + for (_iter655 = this->names.begin(); _iter655 != this->names.end(); ++_iter655) { - xfer += oprot->writeString((*_iter654)); + xfer += oprot->writeString((*_iter655)); } xfer += oprot->writeListEnd(); } @@ -12139,10 +12139,10 @@ uint32_t ThriftHiveMetastore_get_partiti xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->names)).size())); - std::vector<std::string> ::const_iterator _iter655; - for (_iter655 = (*(this->names)).begin(); _iter655 != (*(this->names)).end(); ++_iter655) + std::vector<std::string> ::const_iterator _iter656; + for (_iter656 = (*(this->names)).begin(); _iter656 != (*(this->names)).end(); ++_iter656) { - xfer += oprot->writeString((*_iter655)); + xfer += oprot->writeString((*_iter656)); } xfer += oprot->writeListEnd(); } @@ -12177,14 +12177,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size656; - ::apache::thrift::protocol::TType _etype659; - xfer += iprot->readListBegin(_etype659, _size656); - this->success.resize(_size656); - uint32_t _i660; - for (_i660 = 0; _i660 < _size656; ++_i660) + uint32_t _size657; + ::apache::thrift::protocol::TType _etype660; + xfer += iprot->readListBegin(_etype660, _size657); + this->success.resize(_size657); + uint32_t _i661; + for (_i661 = 0; _i661 < _size657; ++_i661) { - xfer += this->success[_i660].read(iprot); + xfer += this->success[_i661].read(iprot); } xfer += iprot->readListEnd(); } @@ -12231,10 +12231,10 @@ uint32_t ThriftHiveMetastore_get_partiti 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 _iter661; - for (_iter661 = this->success.begin(); _iter661 != this->success.end(); ++_iter661) + std::vector<Partition> ::const_iterator _iter662; + for (_iter662 = this->success.begin(); _iter662 != this->success.end(); ++_iter662) { - xfer += (*_iter661).write(oprot); + xfer += (*_iter662).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12277,14 +12277,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size662; - ::apache::thrift::protocol::TType _etype665; - xfer += iprot->readListBegin(_etype665, _size662); - (*(this->success)).resize(_size662); - uint32_t _i666; - for (_i666 = 0; _i666 < _size662; ++_i666) + uint32_t _size663; + ::apache::thrift::protocol::TType _etype666; + xfer += iprot->readListBegin(_etype666, _size663); + (*(this->success)).resize(_size663); + uint32_t _i667; + for (_i667 = 0; _i667 < _size663; ++_i667) { - xfer += (*(this->success))[_i666].read(iprot); + xfer += (*(this->success))[_i667].read(iprot); } xfer += iprot->readListEnd(); } @@ -12575,14 +12575,14 @@ uint32_t ThriftHiveMetastore_alter_parti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size667; - ::apache::thrift::protocol::TType _etype670; - xfer += iprot->readListBegin(_etype670, _size667); - this->new_parts.resize(_size667); - uint32_t _i671; - for (_i671 = 0; _i671 < _size667; ++_i671) + uint32_t _size668; + ::apache::thrift::protocol::TType _etype671; + xfer += iprot->readListBegin(_etype671, _size668); + this->new_parts.resize(_size668); + uint32_t _i672; + for (_i672 = 0; _i672 < _size668; ++_i672) { - xfer += this->new_parts[_i671].read(iprot); + xfer += this->new_parts[_i672].read(iprot); } xfer += iprot->readListEnd(); } @@ -12618,10 +12618,10 @@ uint32_t ThriftHiveMetastore_alter_parti xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter672; - for (_iter672 = this->new_parts.begin(); _iter672 != this->new_parts.end(); ++_iter672) + std::vector<Partition> ::const_iterator _iter673; + for (_iter673 = this->new_parts.begin(); _iter673 != this->new_parts.end(); ++_iter673) { - xfer += (*_iter672).write(oprot); + xfer += (*_iter673).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12647,10 +12647,10 @@ uint32_t ThriftHiveMetastore_alter_parti xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter673; - for (_iter673 = (*(this->new_parts)).begin(); _iter673 != (*(this->new_parts)).end(); ++_iter673) + std::vector<Partition> ::const_iterator _iter674; + for (_iter674 = (*(this->new_parts)).begin(); _iter674 != (*(this->new_parts)).end(); ++_iter674) { - xfer += (*_iter673).write(oprot); + xfer += (*_iter674).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13047,14 +13047,14 @@ uint32_t ThriftHiveMetastore_rename_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size674; - ::apache::thrift::protocol::TType _etype677; - xfer += iprot->readListBegin(_etype677, _size674); - this->part_vals.resize(_size674); - uint32_t _i678; - for (_i678 = 0; _i678 < _size674; ++_i678) + uint32_t _size675; + ::apache::thrift::protocol::TType _etype678; + xfer += iprot->readListBegin(_etype678, _size675); + this->part_vals.resize(_size675); + uint32_t _i679; + for (_i679 = 0; _i679 < _size675; ++_i679) { - xfer += iprot->readString(this->part_vals[_i678]); + xfer += iprot->readString(this->part_vals[_i679]); } xfer += iprot->readListEnd(); } @@ -13098,10 +13098,10 @@ uint32_t ThriftHiveMetastore_rename_part 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()));
[... 1243 lines stripped ...]
