Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1650145&r1=1650144&r2=1650145&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original) +++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Wed Jan 7 20:15:10 2015 @@ -1096,14 +1096,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size401; - ::apache::thrift::protocol::TType _etype404; - xfer += iprot->readListBegin(_etype404, _size401); - this->success.resize(_size401); - uint32_t _i405; - for (_i405 = 0; _i405 < _size401; ++_i405) + uint32_t _size407; + ::apache::thrift::protocol::TType _etype410; + xfer += iprot->readListBegin(_etype410, _size407); + this->success.resize(_size407); + uint32_t _i411; + for (_i411 = 0; _i411 < _size407; ++_i411) { - xfer += iprot->readString(this->success[_i405]); + xfer += iprot->readString(this->success[_i411]); } xfer += iprot->readListEnd(); } @@ -1142,10 +1142,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 _iter406; - for (_iter406 = this->success.begin(); _iter406 != this->success.end(); ++_iter406) + std::vector<std::string> ::const_iterator _iter412; + for (_iter412 = this->success.begin(); _iter412 != this->success.end(); ++_iter412) { - xfer += oprot->writeString((*_iter406)); + xfer += oprot->writeString((*_iter412)); } xfer += oprot->writeListEnd(); } @@ -1184,14 +1184,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size407; - ::apache::thrift::protocol::TType _etype410; - xfer += iprot->readListBegin(_etype410, _size407); - (*(this->success)).resize(_size407); - uint32_t _i411; - for (_i411 = 0; _i411 < _size407; ++_i411) + uint32_t _size413; + ::apache::thrift::protocol::TType _etype416; + xfer += iprot->readListBegin(_etype416, _size413); + (*(this->success)).resize(_size413); + uint32_t _i417; + for (_i417 = 0; _i417 < _size413; ++_i417) { - xfer += iprot->readString((*(this->success))[_i411]); + xfer += iprot->readString((*(this->success))[_i417]); } xfer += iprot->readListEnd(); } @@ -1289,14 +1289,14 @@ uint32_t ThriftHiveMetastore_get_all_dat if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size412; - ::apache::thrift::protocol::TType _etype415; - xfer += iprot->readListBegin(_etype415, _size412); - this->success.resize(_size412); - uint32_t _i416; - for (_i416 = 0; _i416 < _size412; ++_i416) + uint32_t _size418; + ::apache::thrift::protocol::TType _etype421; + xfer += iprot->readListBegin(_etype421, _size418); + this->success.resize(_size418); + uint32_t _i422; + for (_i422 = 0; _i422 < _size418; ++_i422) { - xfer += iprot->readString(this->success[_i416]); + xfer += iprot->readString(this->success[_i422]); } xfer += iprot->readListEnd(); } @@ -1335,10 +1335,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 _iter417; - for (_iter417 = this->success.begin(); _iter417 != this->success.end(); ++_iter417) + std::vector<std::string> ::const_iterator _iter423; + for (_iter423 = this->success.begin(); _iter423 != this->success.end(); ++_iter423) { - xfer += oprot->writeString((*_iter417)); + xfer += oprot->writeString((*_iter423)); } xfer += oprot->writeListEnd(); } @@ -1377,14 +1377,14 @@ uint32_t ThriftHiveMetastore_get_all_dat if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size418; - ::apache::thrift::protocol::TType _etype421; - xfer += iprot->readListBegin(_etype421, _size418); - (*(this->success)).resize(_size418); - uint32_t _i422; - for (_i422 = 0; _i422 < _size418; ++_i422) + uint32_t _size424; + ::apache::thrift::protocol::TType _etype427; + xfer += iprot->readListBegin(_etype427, _size424); + (*(this->success)).resize(_size424); + uint32_t _i428; + for (_i428 = 0; _i428 < _size424; ++_i428) { - xfer += iprot->readString((*(this->success))[_i422]); + xfer += iprot->readString((*(this->success))[_i428]); } xfer += iprot->readListEnd(); } @@ -2327,17 +2327,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size423; - ::apache::thrift::protocol::TType _ktype424; - ::apache::thrift::protocol::TType _vtype425; - xfer += iprot->readMapBegin(_ktype424, _vtype425, _size423); - uint32_t _i427; - for (_i427 = 0; _i427 < _size423; ++_i427) + uint32_t _size429; + ::apache::thrift::protocol::TType _ktype430; + ::apache::thrift::protocol::TType _vtype431; + xfer += iprot->readMapBegin(_ktype430, _vtype431, _size429); + uint32_t _i433; + for (_i433 = 0; _i433 < _size429; ++_i433) { - std::string _key428; - xfer += iprot->readString(_key428); - Type& _val429 = this->success[_key428]; - xfer += _val429.read(iprot); + std::string _key434; + xfer += iprot->readString(_key434); + Type& _val435 = this->success[_key434]; + xfer += _val435.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2376,11 +2376,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 _iter430; - for (_iter430 = this->success.begin(); _iter430 != this->success.end(); ++_iter430) + std::map<std::string, Type> ::const_iterator _iter436; + for (_iter436 = this->success.begin(); _iter436 != this->success.end(); ++_iter436) { - xfer += oprot->writeString(_iter430->first); - xfer += _iter430->second.write(oprot); + xfer += oprot->writeString(_iter436->first); + xfer += _iter436->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2419,17 +2419,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size431; - ::apache::thrift::protocol::TType _ktype432; - ::apache::thrift::protocol::TType _vtype433; - xfer += iprot->readMapBegin(_ktype432, _vtype433, _size431); - uint32_t _i435; - for (_i435 = 0; _i435 < _size431; ++_i435) + uint32_t _size437; + ::apache::thrift::protocol::TType _ktype438; + ::apache::thrift::protocol::TType _vtype439; + xfer += iprot->readMapBegin(_ktype438, _vtype439, _size437); + uint32_t _i441; + for (_i441 = 0; _i441 < _size437; ++_i441) { - std::string _key436; - xfer += iprot->readString(_key436); - Type& _val437 = (*(this->success))[_key436]; - xfer += _val437.read(iprot); + std::string _key442; + xfer += iprot->readString(_key442); + Type& _val443 = (*(this->success))[_key442]; + xfer += _val443.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2564,14 +2564,14 @@ uint32_t ThriftHiveMetastore_get_fields_ 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 _size444; + ::apache::thrift::protocol::TType _etype447; + xfer += iprot->readListBegin(_etype447, _size444); + this->success.resize(_size444); + uint32_t _i448; + for (_i448 = 0; _i448 < _size444; ++_i448) { - xfer += this->success[_i442].read(iprot); + xfer += this->success[_i448].read(iprot); } xfer += iprot->readListEnd(); } @@ -2626,10 +2626,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 _iter443; - for (_iter443 = this->success.begin(); _iter443 != this->success.end(); ++_iter443) + std::vector<FieldSchema> ::const_iterator _iter449; + for (_iter449 = this->success.begin(); _iter449 != this->success.end(); ++_iter449) { - xfer += (*_iter443).write(oprot); + xfer += (*_iter449).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2676,14 +2676,14 @@ uint32_t ThriftHiveMetastore_get_fields_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size444; - ::apache::thrift::protocol::TType _etype447; - xfer += iprot->readListBegin(_etype447, _size444); - (*(this->success)).resize(_size444); - uint32_t _i448; - for (_i448 = 0; _i448 < _size444; ++_i448) + 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) { - xfer += (*(this->success))[_i448].read(iprot); + xfer += (*(this->success))[_i454].read(iprot); } xfer += iprot->readListEnd(); } @@ -2834,14 +2834,14 @@ uint32_t ThriftHiveMetastore_get_schema_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size449; - ::apache::thrift::protocol::TType _etype452; - xfer += iprot->readListBegin(_etype452, _size449); - this->success.resize(_size449); - uint32_t _i453; - for (_i453 = 0; _i453 < _size449; ++_i453) + uint32_t _size455; + ::apache::thrift::protocol::TType _etype458; + xfer += iprot->readListBegin(_etype458, _size455); + this->success.resize(_size455); + uint32_t _i459; + for (_i459 = 0; _i459 < _size455; ++_i459) { - xfer += this->success[_i453].read(iprot); + xfer += this->success[_i459].read(iprot); } xfer += iprot->readListEnd(); } @@ -2896,10 +2896,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 _iter454; - for (_iter454 = this->success.begin(); _iter454 != this->success.end(); ++_iter454) + std::vector<FieldSchema> ::const_iterator _iter460; + for (_iter460 = this->success.begin(); _iter460 != this->success.end(); ++_iter460) { - xfer += (*_iter454).write(oprot); + xfer += (*_iter460).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2946,14 +2946,14 @@ uint32_t ThriftHiveMetastore_get_schema_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size455; - ::apache::thrift::protocol::TType _etype458; - xfer += iprot->readListBegin(_etype458, _size455); - (*(this->success)).resize(_size455); - uint32_t _i459; - for (_i459 = 0; _i459 < _size455; ++_i459) + 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) { - xfer += (*(this->success))[_i459].read(iprot); + xfer += (*(this->success))[_i465].read(iprot); } xfer += iprot->readListEnd(); } @@ -4008,14 +4008,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size460; - ::apache::thrift::protocol::TType _etype463; - xfer += iprot->readListBegin(_etype463, _size460); - this->success.resize(_size460); - uint32_t _i464; - for (_i464 = 0; _i464 < _size460; ++_i464) + uint32_t _size466; + ::apache::thrift::protocol::TType _etype469; + xfer += iprot->readListBegin(_etype469, _size466); + this->success.resize(_size466); + uint32_t _i470; + for (_i470 = 0; _i470 < _size466; ++_i470) { - xfer += iprot->readString(this->success[_i464]); + xfer += iprot->readString(this->success[_i470]); } xfer += iprot->readListEnd(); } @@ -4054,10 +4054,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 _iter465; - for (_iter465 = this->success.begin(); _iter465 != this->success.end(); ++_iter465) + std::vector<std::string> ::const_iterator _iter471; + for (_iter471 = this->success.begin(); _iter471 != this->success.end(); ++_iter471) { - xfer += oprot->writeString((*_iter465)); + xfer += oprot->writeString((*_iter471)); } xfer += oprot->writeListEnd(); } @@ -4096,14 +4096,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size466; - ::apache::thrift::protocol::TType _etype469; - xfer += iprot->readListBegin(_etype469, _size466); - (*(this->success)).resize(_size466); - uint32_t _i470; - for (_i470 = 0; _i470 < _size466; ++_i470) + uint32_t _size472; + ::apache::thrift::protocol::TType _etype475; + xfer += iprot->readListBegin(_etype475, _size472); + (*(this->success)).resize(_size472); + uint32_t _i476; + for (_i476 = 0; _i476 < _size472; ++_i476) { - xfer += iprot->readString((*(this->success))[_i470]); + xfer += iprot->readString((*(this->success))[_i476]); } xfer += iprot->readListEnd(); } @@ -4222,14 +4222,14 @@ uint32_t ThriftHiveMetastore_get_all_tab if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size471; - ::apache::thrift::protocol::TType _etype474; - xfer += iprot->readListBegin(_etype474, _size471); - this->success.resize(_size471); - uint32_t _i475; - for (_i475 = 0; _i475 < _size471; ++_i475) + uint32_t _size477; + ::apache::thrift::protocol::TType _etype480; + xfer += iprot->readListBegin(_etype480, _size477); + this->success.resize(_size477); + uint32_t _i481; + for (_i481 = 0; _i481 < _size477; ++_i481) { - xfer += iprot->readString(this->success[_i475]); + xfer += iprot->readString(this->success[_i481]); } xfer += iprot->readListEnd(); } @@ -4268,10 +4268,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 _iter476; - for (_iter476 = this->success.begin(); _iter476 != this->success.end(); ++_iter476) + std::vector<std::string> ::const_iterator _iter482; + for (_iter482 = this->success.begin(); _iter482 != this->success.end(); ++_iter482) { - xfer += oprot->writeString((*_iter476)); + xfer += oprot->writeString((*_iter482)); } xfer += oprot->writeListEnd(); } @@ -4310,14 +4310,14 @@ uint32_t ThriftHiveMetastore_get_all_tab if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size477; - ::apache::thrift::protocol::TType _etype480; - xfer += iprot->readListBegin(_etype480, _size477); - (*(this->success)).resize(_size477); - uint32_t _i481; - for (_i481 = 0; _i481 < _size477; ++_i481) + uint32_t _size483; + ::apache::thrift::protocol::TType _etype486; + xfer += iprot->readListBegin(_etype486, _size483); + (*(this->success)).resize(_size483); + uint32_t _i487; + for (_i487 = 0; _i487 < _size483; ++_i487) { - xfer += iprot->readString((*(this->success))[_i481]); + xfer += iprot->readString((*(this->success))[_i487]); } xfer += iprot->readListEnd(); } @@ -4596,14 +4596,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size482; - ::apache::thrift::protocol::TType _etype485; - xfer += iprot->readListBegin(_etype485, _size482); - this->tbl_names.resize(_size482); - uint32_t _i486; - for (_i486 = 0; _i486 < _size482; ++_i486) + uint32_t _size488; + ::apache::thrift::protocol::TType _etype491; + xfer += iprot->readListBegin(_etype491, _size488); + this->tbl_names.resize(_size488); + uint32_t _i492; + for (_i492 = 0; _i492 < _size488; ++_i492) { - xfer += iprot->readString(this->tbl_names[_i486]); + xfer += iprot->readString(this->tbl_names[_i492]); } xfer += iprot->readListEnd(); } @@ -4635,10 +4635,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 _iter487; - for (_iter487 = this->tbl_names.begin(); _iter487 != this->tbl_names.end(); ++_iter487) + std::vector<std::string> ::const_iterator _iter493; + for (_iter493 = this->tbl_names.begin(); _iter493 != this->tbl_names.end(); ++_iter493) { - xfer += oprot->writeString((*_iter487)); + xfer += oprot->writeString((*_iter493)); } xfer += oprot->writeListEnd(); } @@ -4660,10 +4660,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 _iter488; - for (_iter488 = (*(this->tbl_names)).begin(); _iter488 != (*(this->tbl_names)).end(); ++_iter488) + std::vector<std::string> ::const_iterator _iter494; + for (_iter494 = (*(this->tbl_names)).begin(); _iter494 != (*(this->tbl_names)).end(); ++_iter494) { - xfer += oprot->writeString((*_iter488)); + xfer += oprot->writeString((*_iter494)); } xfer += oprot->writeListEnd(); } @@ -4698,14 +4698,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size489; - ::apache::thrift::protocol::TType _etype492; - xfer += iprot->readListBegin(_etype492, _size489); - this->success.resize(_size489); - uint32_t _i493; - for (_i493 = 0; _i493 < _size489; ++_i493) + uint32_t _size495; + ::apache::thrift::protocol::TType _etype498; + xfer += iprot->readListBegin(_etype498, _size495); + this->success.resize(_size495); + uint32_t _i499; + for (_i499 = 0; _i499 < _size495; ++_i499) { - xfer += this->success[_i493].read(iprot); + xfer += this->success[_i499].read(iprot); } xfer += iprot->readListEnd(); } @@ -4760,10 +4760,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 _iter494; - for (_iter494 = this->success.begin(); _iter494 != this->success.end(); ++_iter494) + std::vector<Table> ::const_iterator _iter500; + for (_iter500 = this->success.begin(); _iter500 != this->success.end(); ++_iter500) { - xfer += (*_iter494).write(oprot); + xfer += (*_iter500).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4810,14 +4810,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size495; - ::apache::thrift::protocol::TType _etype498; - xfer += iprot->readListBegin(_etype498, _size495); - (*(this->success)).resize(_size495); - uint32_t _i499; - for (_i499 = 0; _i499 < _size495; ++_i499) + uint32_t _size501; + ::apache::thrift::protocol::TType _etype504; + xfer += iprot->readListBegin(_etype504, _size501); + (*(this->success)).resize(_size501); + uint32_t _i505; + for (_i505 = 0; _i505 < _size501; ++_i505) { - xfer += (*(this->success))[_i499].read(iprot); + xfer += (*(this->success))[_i505].read(iprot); } xfer += iprot->readListEnd(); } @@ -4984,14 +4984,14 @@ uint32_t ThriftHiveMetastore_get_table_n if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size500; - ::apache::thrift::protocol::TType _etype503; - xfer += iprot->readListBegin(_etype503, _size500); - this->success.resize(_size500); - uint32_t _i504; - for (_i504 = 0; _i504 < _size500; ++_i504) + uint32_t _size506; + ::apache::thrift::protocol::TType _etype509; + xfer += iprot->readListBegin(_etype509, _size506); + this->success.resize(_size506); + uint32_t _i510; + for (_i510 = 0; _i510 < _size506; ++_i510) { - xfer += iprot->readString(this->success[_i504]); + xfer += iprot->readString(this->success[_i510]); } xfer += iprot->readListEnd(); } @@ -5046,10 +5046,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 _iter505; - for (_iter505 = this->success.begin(); _iter505 != this->success.end(); ++_iter505) + std::vector<std::string> ::const_iterator _iter511; + for (_iter511 = this->success.begin(); _iter511 != this->success.end(); ++_iter511) { - xfer += oprot->writeString((*_iter505)); + xfer += oprot->writeString((*_iter511)); } xfer += oprot->writeListEnd(); } @@ -5096,14 +5096,14 @@ uint32_t ThriftHiveMetastore_get_table_n if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size506; - ::apache::thrift::protocol::TType _etype509; - xfer += iprot->readListBegin(_etype509, _size506); - (*(this->success)).resize(_size506); - uint32_t _i510; - for (_i510 = 0; _i510 < _size506; ++_i510) + uint32_t _size512; + ::apache::thrift::protocol::TType _etype515; + xfer += iprot->readListBegin(_etype515, _size512); + (*(this->success)).resize(_size512); + uint32_t _i516; + for (_i516 = 0; _i516 < _size512; ++_i516) { - xfer += iprot->readString((*(this->success))[_i510]); + xfer += iprot->readString((*(this->success))[_i516]); } xfer += iprot->readListEnd(); } @@ -6306,14 +6306,14 @@ uint32_t ThriftHiveMetastore_add_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size511; - ::apache::thrift::protocol::TType _etype514; - xfer += iprot->readListBegin(_etype514, _size511); - this->new_parts.resize(_size511); - uint32_t _i515; - for (_i515 = 0; _i515 < _size511; ++_i515) + uint32_t _size517; + ::apache::thrift::protocol::TType _etype520; + xfer += iprot->readListBegin(_etype520, _size517); + this->new_parts.resize(_size517); + uint32_t _i521; + for (_i521 = 0; _i521 < _size517; ++_i521) { - xfer += this->new_parts[_i515].read(iprot); + xfer += this->new_parts[_i521].read(iprot); } xfer += iprot->readListEnd(); } @@ -6341,10 +6341,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 _iter516; - for (_iter516 = this->new_parts.begin(); _iter516 != this->new_parts.end(); ++_iter516) + std::vector<Partition> ::const_iterator _iter522; + for (_iter522 = this->new_parts.begin(); _iter522 != this->new_parts.end(); ++_iter522) { - xfer += (*_iter516).write(oprot); + xfer += (*_iter522).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6362,10 +6362,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 _iter517; - for (_iter517 = (*(this->new_parts)).begin(); _iter517 != (*(this->new_parts)).end(); ++_iter517) + std::vector<Partition> ::const_iterator _iter523; + for (_iter523 = (*(this->new_parts)).begin(); _iter523 != (*(this->new_parts)).end(); ++_iter523) { - xfer += (*_iter517).write(oprot); + xfer += (*_iter523).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6556,14 +6556,14 @@ uint32_t ThriftHiveMetastore_add_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size518; - ::apache::thrift::protocol::TType _etype521; - xfer += iprot->readListBegin(_etype521, _size518); - this->new_parts.resize(_size518); - uint32_t _i522; - for (_i522 = 0; _i522 < _size518; ++_i522) + uint32_t _size524; + ::apache::thrift::protocol::TType _etype527; + xfer += iprot->readListBegin(_etype527, _size524); + this->new_parts.resize(_size524); + uint32_t _i528; + for (_i528 = 0; _i528 < _size524; ++_i528) { - xfer += this->new_parts[_i522].read(iprot); + xfer += this->new_parts[_i528].read(iprot); } xfer += iprot->readListEnd(); } @@ -6591,10 +6591,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<PartitionSpec> ::const_iterator _iter523; - for (_iter523 = this->new_parts.begin(); _iter523 != this->new_parts.end(); ++_iter523) + std::vector<PartitionSpec> ::const_iterator _iter529; + for (_iter529 = this->new_parts.begin(); _iter529 != this->new_parts.end(); ++_iter529) { - xfer += (*_iter523).write(oprot); + xfer += (*_iter529).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6612,10 +6612,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<PartitionSpec> ::const_iterator _iter524; - for (_iter524 = (*(this->new_parts)).begin(); _iter524 != (*(this->new_parts)).end(); ++_iter524) + std::vector<PartitionSpec> ::const_iterator _iter530; + for (_iter530 = (*(this->new_parts)).begin(); _iter530 != (*(this->new_parts)).end(); ++_iter530) { - xfer += (*_iter524).write(oprot); + xfer += (*_iter530).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6822,14 +6822,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size525; - ::apache::thrift::protocol::TType _etype528; - xfer += iprot->readListBegin(_etype528, _size525); - this->part_vals.resize(_size525); - uint32_t _i529; - for (_i529 = 0; _i529 < _size525; ++_i529) + uint32_t _size531; + ::apache::thrift::protocol::TType _etype534; + xfer += iprot->readListBegin(_etype534, _size531); + this->part_vals.resize(_size531); + uint32_t _i535; + for (_i535 = 0; _i535 < _size531; ++_i535) { - xfer += iprot->readString(this->part_vals[_i529]); + xfer += iprot->readString(this->part_vals[_i535]); } xfer += iprot->readListEnd(); } @@ -6865,10 +6865,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 _iter530; - for (_iter530 = this->part_vals.begin(); _iter530 != this->part_vals.end(); ++_iter530) + std::vector<std::string> ::const_iterator _iter536; + for (_iter536 = this->part_vals.begin(); _iter536 != this->part_vals.end(); ++_iter536) { - xfer += oprot->writeString((*_iter530)); + xfer += oprot->writeString((*_iter536)); } xfer += oprot->writeListEnd(); } @@ -6894,10 +6894,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 _iter531; - for (_iter531 = (*(this->part_vals)).begin(); _iter531 != (*(this->part_vals)).end(); ++_iter531) + std::vector<std::string> ::const_iterator _iter537; + for (_iter537 = (*(this->part_vals)).begin(); _iter537 != (*(this->part_vals)).end(); ++_iter537) { - xfer += oprot->writeString((*_iter531)); + xfer += oprot->writeString((*_iter537)); } xfer += oprot->writeListEnd(); } @@ -7326,14 +7326,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size532; - ::apache::thrift::protocol::TType _etype535; - xfer += iprot->readListBegin(_etype535, _size532); - this->part_vals.resize(_size532); - uint32_t _i536; - for (_i536 = 0; _i536 < _size532; ++_i536) + uint32_t _size538; + ::apache::thrift::protocol::TType _etype541; + xfer += iprot->readListBegin(_etype541, _size538); + this->part_vals.resize(_size538); + uint32_t _i542; + for (_i542 = 0; _i542 < _size538; ++_i542) { - xfer += iprot->readString(this->part_vals[_i536]); + xfer += iprot->readString(this->part_vals[_i542]); } xfer += iprot->readListEnd(); } @@ -7377,10 +7377,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 _iter537; - for (_iter537 = this->part_vals.begin(); _iter537 != this->part_vals.end(); ++_iter537) + std::vector<std::string> ::const_iterator _iter543; + for (_iter543 = this->part_vals.begin(); _iter543 != this->part_vals.end(); ++_iter543) { - xfer += oprot->writeString((*_iter537)); + xfer += oprot->writeString((*_iter543)); } xfer += oprot->writeListEnd(); } @@ -7410,10 +7410,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 _iter538; - for (_iter538 = (*(this->part_vals)).begin(); _iter538 != (*(this->part_vals)).end(); ++_iter538) + std::vector<std::string> ::const_iterator _iter544; + for (_iter544 = (*(this->part_vals)).begin(); _iter544 != (*(this->part_vals)).end(); ++_iter544) { - xfer += oprot->writeString((*_iter538)); + xfer += oprot->writeString((*_iter544)); } xfer += oprot->writeListEnd(); } @@ -8148,14 +8148,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size539; - ::apache::thrift::protocol::TType _etype542; - xfer += iprot->readListBegin(_etype542, _size539); - this->part_vals.resize(_size539); - uint32_t _i543; - for (_i543 = 0; _i543 < _size539; ++_i543) + uint32_t _size545; + ::apache::thrift::protocol::TType _etype548; + xfer += iprot->readListBegin(_etype548, _size545); + this->part_vals.resize(_size545); + uint32_t _i549; + for (_i549 = 0; _i549 < _size545; ++_i549) { - xfer += iprot->readString(this->part_vals[_i543]); + xfer += iprot->readString(this->part_vals[_i549]); } xfer += iprot->readListEnd(); } @@ -8199,10 +8199,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 _iter544; - for (_iter544 = this->part_vals.begin(); _iter544 != this->part_vals.end(); ++_iter544) + std::vector<std::string> ::const_iterator _iter550; + for (_iter550 = this->part_vals.begin(); _iter550 != this->part_vals.end(); ++_iter550) { - xfer += oprot->writeString((*_iter544)); + xfer += oprot->writeString((*_iter550)); } xfer += oprot->writeListEnd(); } @@ -8232,10 +8232,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 _iter545; - for (_iter545 = (*(this->part_vals)).begin(); _iter545 != (*(this->part_vals)).end(); ++_iter545) + std::vector<std::string> ::const_iterator _iter551; + for (_iter551 = (*(this->part_vals)).begin(); _iter551 != (*(this->part_vals)).end(); ++_iter551) { - xfer += oprot->writeString((*_iter545)); + xfer += oprot->writeString((*_iter551)); } xfer += oprot->writeListEnd(); } @@ -8426,14 +8426,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size546; - ::apache::thrift::protocol::TType _etype549; - xfer += iprot->readListBegin(_etype549, _size546); - this->part_vals.resize(_size546); - uint32_t _i550; - for (_i550 = 0; _i550 < _size546; ++_i550) + uint32_t _size552; + ::apache::thrift::protocol::TType _etype555; + xfer += iprot->readListBegin(_etype555, _size552); + this->part_vals.resize(_size552); + uint32_t _i556; + for (_i556 = 0; _i556 < _size552; ++_i556) { - xfer += iprot->readString(this->part_vals[_i550]); + xfer += iprot->readString(this->part_vals[_i556]); } xfer += iprot->readListEnd(); } @@ -8485,10 +8485,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 _iter551; - for (_iter551 = this->part_vals.begin(); _iter551 != this->part_vals.end(); ++_iter551) + std::vector<std::string> ::const_iterator _iter557; + for (_iter557 = this->part_vals.begin(); _iter557 != this->part_vals.end(); ++_iter557) { - xfer += oprot->writeString((*_iter551)); + xfer += oprot->writeString((*_iter557)); } xfer += oprot->writeListEnd(); } @@ -8522,10 +8522,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 _iter552; - for (_iter552 = (*(this->part_vals)).begin(); _iter552 != (*(this->part_vals)).end(); ++_iter552) + std::vector<std::string> ::const_iterator _iter558; + for (_iter558 = (*(this->part_vals)).begin(); _iter558 != (*(this->part_vals)).end(); ++_iter558) { - xfer += oprot->writeString((*_iter552)); + xfer += oprot->writeString((*_iter558)); } xfer += oprot->writeListEnd(); } @@ -9438,14 +9438,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size553; - ::apache::thrift::protocol::TType _etype556; - xfer += iprot->readListBegin(_etype556, _size553); - this->part_vals.resize(_size553); - uint32_t _i557; - for (_i557 = 0; _i557 < _size553; ++_i557) + uint32_t _size559; + ::apache::thrift::protocol::TType _etype562; + xfer += iprot->readListBegin(_etype562, _size559); + this->part_vals.resize(_size559); + uint32_t _i563; + for (_i563 = 0; _i563 < _size559; ++_i563) { - xfer += iprot->readString(this->part_vals[_i557]); + xfer += iprot->readString(this->part_vals[_i563]); } xfer += iprot->readListEnd(); } @@ -9481,10 +9481,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 _iter558; - for (_iter558 = this->part_vals.begin(); _iter558 != this->part_vals.end(); ++_iter558) + std::vector<std::string> ::const_iterator _iter564; + for (_iter564 = this->part_vals.begin(); _iter564 != this->part_vals.end(); ++_iter564) { - xfer += oprot->writeString((*_iter558)); + xfer += oprot->writeString((*_iter564)); } xfer += oprot->writeListEnd(); } @@ -9510,10 +9510,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 _iter559; - for (_iter559 = (*(this->part_vals)).begin(); _iter559 != (*(this->part_vals)).end(); ++_iter559) + std::vector<std::string> ::const_iterator _iter565; + for (_iter565 = (*(this->part_vals)).begin(); _iter565 != (*(this->part_vals)).end(); ++_iter565) { - xfer += oprot->writeString((*_iter559)); + xfer += oprot->writeString((*_iter565)); } xfer += oprot->writeListEnd(); } @@ -9684,17 +9684,17 @@ uint32_t ThriftHiveMetastore_exchange_pa if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size560; - ::apache::thrift::protocol::TType _ktype561; - ::apache::thrift::protocol::TType _vtype562; - xfer += iprot->readMapBegin(_ktype561, _vtype562, _size560); - uint32_t _i564; - for (_i564 = 0; _i564 < _size560; ++_i564) + uint32_t _size566; + ::apache::thrift::protocol::TType _ktype567; + ::apache::thrift::protocol::TType _vtype568; + xfer += iprot->readMapBegin(_ktype567, _vtype568, _size566); + uint32_t _i570; + for (_i570 = 0; _i570 < _size566; ++_i570) { - std::string _key565; - xfer += iprot->readString(_key565); - std::string& _val566 = this->partitionSpecs[_key565]; - xfer += iprot->readString(_val566); + std::string _key571; + xfer += iprot->readString(_key571); + std::string& _val572 = this->partitionSpecs[_key571]; + xfer += iprot->readString(_val572); } xfer += iprot->readMapEnd(); } @@ -9754,11 +9754,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 _iter567; - for (_iter567 = this->partitionSpecs.begin(); _iter567 != this->partitionSpecs.end(); ++_iter567) + std::map<std::string, std::string> ::const_iterator _iter573; + for (_iter573 = this->partitionSpecs.begin(); _iter573 != this->partitionSpecs.end(); ++_iter573) { - xfer += oprot->writeString(_iter567->first); - xfer += oprot->writeString(_iter567->second); + xfer += oprot->writeString(_iter573->first); + xfer += oprot->writeString(_iter573->second); } xfer += oprot->writeMapEnd(); } @@ -9792,11 +9792,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 _iter568; - for (_iter568 = (*(this->partitionSpecs)).begin(); _iter568 != (*(this->partitionSpecs)).end(); ++_iter568) + std::map<std::string, std::string> ::const_iterator _iter574; + for (_iter574 = (*(this->partitionSpecs)).begin(); _iter574 != (*(this->partitionSpecs)).end(); ++_iter574) { - xfer += oprot->writeString(_iter568->first); - xfer += oprot->writeString(_iter568->second); + xfer += oprot->writeString(_iter574->first); + xfer += oprot->writeString(_iter574->second); } xfer += oprot->writeMapEnd(); } @@ -10039,14 +10039,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size569; - ::apache::thrift::protocol::TType _etype572; - xfer += iprot->readListBegin(_etype572, _size569); - this->part_vals.resize(_size569); - uint32_t _i573; - for (_i573 = 0; _i573 < _size569; ++_i573) + uint32_t _size575; + ::apache::thrift::protocol::TType _etype578; + xfer += iprot->readListBegin(_etype578, _size575); + this->part_vals.resize(_size575); + uint32_t _i579; + for (_i579 = 0; _i579 < _size575; ++_i579) { - xfer += iprot->readString(this->part_vals[_i573]); + xfer += iprot->readString(this->part_vals[_i579]); } xfer += iprot->readListEnd(); } @@ -10067,14 +10067,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - this->group_names.resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + uint32_t _size580; + ::apache::thrift::protocol::TType _etype583; + xfer += iprot->readListBegin(_etype583, _size580); + this->group_names.resize(_size580); + uint32_t _i584; + for (_i584 = 0; _i584 < _size580; ++_i584) { - xfer += iprot->readString(this->group_names[_i578]); + xfer += iprot->readString(this->group_names[_i584]); } xfer += iprot->readListEnd(); } @@ -10110,10 +10110,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 _iter579; - for (_iter579 = this->part_vals.begin(); _iter579 != this->part_vals.end(); ++_iter579) + std::vector<std::string> ::const_iterator _iter585; + for (_iter585 = this->part_vals.begin(); _iter585 != this->part_vals.end(); ++_iter585) { - xfer += oprot->writeString((*_iter579)); + xfer += oprot->writeString((*_iter585)); } xfer += oprot->writeListEnd(); } @@ -10126,10 +10126,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 _iter580; - for (_iter580 = this->group_names.begin(); _iter580 != this->group_names.end(); ++_iter580) + std::vector<std::string> ::const_iterator _iter586; + for (_iter586 = this->group_names.begin(); _iter586 != this->group_names.end(); ++_iter586) { - xfer += oprot->writeString((*_iter580)); + xfer += oprot->writeString((*_iter586)); } xfer += oprot->writeListEnd(); } @@ -10155,10 +10155,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 _iter581; - for (_iter581 = (*(this->part_vals)).begin(); _iter581 != (*(this->part_vals)).end(); ++_iter581) + std::vector<std::string> ::const_iterator _iter587; + for (_iter587 = (*(this->part_vals)).begin(); _iter587 != (*(this->part_vals)).end(); ++_iter587) { - xfer += oprot->writeString((*_iter581)); + xfer += oprot->writeString((*_iter587)); } xfer += oprot->writeListEnd(); } @@ -10171,10 +10171,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 _iter582; - for (_iter582 = (*(this->group_names)).begin(); _iter582 != (*(this->group_names)).end(); ++_iter582) + std::vector<std::string> ::const_iterator _iter588; + for (_iter588 = (*(this->group_names)).begin(); _iter588 != (*(this->group_names)).end(); ++_iter588) { - xfer += oprot->writeString((*_iter582)); + xfer += oprot->writeString((*_iter588)); } xfer += oprot->writeListEnd(); } @@ -10677,14 +10677,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size583; - ::apache::thrift::protocol::TType _etype586; - xfer += iprot->readListBegin(_etype586, _size583); - this->success.resize(_size583); - uint32_t _i587; - for (_i587 = 0; _i587 < _size583; ++_i587) + uint32_t _size589; + ::apache::thrift::protocol::TType _etype592; + xfer += iprot->readListBegin(_etype592, _size589); + this->success.resize(_size589); + uint32_t _i593; + for (_i593 = 0; _i593 < _size589; ++_i593) { - xfer += this->success[_i587].read(iprot); + xfer += this->success[_i593].read(iprot); } xfer += iprot->readListEnd(); } @@ -10731,10 +10731,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 _iter588; - for (_iter588 = this->success.begin(); _iter588 != this->success.end(); ++_iter588) + std::vector<Partition> ::const_iterator _iter594; + for (_iter594 = this->success.begin(); _iter594 != this->success.end(); ++_iter594) { - xfer += (*_iter588).write(oprot); + xfer += (*_iter594).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10777,14 +10777,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size589; - ::apache::thrift::protocol::TType _etype592; - xfer += iprot->readListBegin(_etype592, _size589); - (*(this->success)).resize(_size589); - uint32_t _i593; - for (_i593 = 0; _i593 < _size589; ++_i593) + uint32_t _size595; + ::apache::thrift::protocol::TType _etype598; + xfer += iprot->readListBegin(_etype598, _size595); + (*(this->success)).resize(_size595); + uint32_t _i599; + for (_i599 = 0; _i599 < _size595; ++_i599) { - xfer += (*(this->success))[_i593].read(iprot); + xfer += (*(this->success))[_i599].read(iprot); } xfer += iprot->readListEnd(); } @@ -10877,14 +10877,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size594; - ::apache::thrift::protocol::TType _etype597; - xfer += iprot->readListBegin(_etype597, _size594); - this->group_names.resize(_size594); - uint32_t _i598; - for (_i598 = 0; _i598 < _size594; ++_i598) + 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) { - xfer += iprot->readString(this->group_names[_i598]); + xfer += iprot->readString(this->group_names[_i604]); } xfer += iprot->readListEnd(); } @@ -10928,10 +10928,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 _iter599; - for (_iter599 = this->group_names.begin(); _iter599 != this->group_names.end(); ++_iter599) + std::vector<std::string> ::const_iterator _iter605; + for (_iter605 = this->group_names.begin(); _iter605 != this->group_names.end(); ++_iter605) { - xfer += oprot->writeString((*_iter599)); + xfer += oprot->writeString((*_iter605)); } xfer += oprot->writeListEnd(); } @@ -10965,10 +10965,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 _iter600; - for (_iter600 = (*(this->group_names)).begin(); _iter600 != (*(this->group_names)).end(); ++_iter600) + std::vector<std::string> ::const_iterator _iter606; + for (_iter606 = (*(this->group_names)).begin(); _iter606 != (*(this->group_names)).end(); ++_iter606) { - xfer += oprot->writeString((*_iter600)); + xfer += oprot->writeString((*_iter606)); } xfer += oprot->writeListEnd(); } @@ -11003,14 +11003,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size601; - ::apache::thrift::protocol::TType _etype604; - xfer += iprot->readListBegin(_etype604, _size601); - this->success.resize(_size601); - uint32_t _i605; - for (_i605 = 0; _i605 < _size601; ++_i605) + uint32_t _size607; + ::apache::thrift::protocol::TType _etype610; + xfer += iprot->readListBegin(_etype610, _size607); + this->success.resize(_size607); + uint32_t _i611; + for (_i611 = 0; _i611 < _size607; ++_i611) { - xfer += this->success[_i605].read(iprot); + xfer += this->success[_i611].read(iprot); } xfer += iprot->readListEnd(); } @@ -11057,10 +11057,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 _iter606; - for (_iter606 = this->success.begin(); _iter606 != this->success.end(); ++_iter606) + std::vector<Partition> ::const_iterator _iter612; + for (_iter612 = this->success.begin(); _iter612 != this->success.end(); ++_iter612) { - xfer += (*_iter606).write(oprot); + xfer += (*_iter612).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11103,14 +11103,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size607; - ::apache::thrift::protocol::TType _etype610; - xfer += iprot->readListBegin(_etype610, _size607); - (*(this->success)).resize(_size607); - uint32_t _i611; - for (_i611 = 0; _i611 < _size607; ++_i611) + uint32_t _size613; + ::apache::thrift::protocol::TType _etype616; + xfer += iprot->readListBegin(_etype616, _size613); + (*(this->success)).resize(_size613); + uint32_t _i617; + for (_i617 = 0; _i617 < _size613; ++_i617) { - xfer += (*(this->success))[_i611].read(iprot); + xfer += (*(this->success))[_i617].read(iprot); } xfer += iprot->readListEnd(); } @@ -11269,14 +11269,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size612; - ::apache::thrift::protocol::TType _etype615; - xfer += iprot->readListBegin(_etype615, _size612); - this->success.resize(_size612); - uint32_t _i616; - for (_i616 = 0; _i616 < _size612; ++_i616) + uint32_t _size618; + ::apache::thrift::protocol::TType _etype621; + xfer += iprot->readListBegin(_etype621, _size618); + this->success.resize(_size618); + uint32_t _i622; + for (_i622 = 0; _i622 < _size618; ++_i622) { - xfer += this->success[_i616].read(iprot); + xfer += this->success[_i622].read(iprot); } xfer += iprot->readListEnd(); } @@ -11323,10 +11323,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<PartitionSpec> ::const_iterator _iter617; - for (_iter617 = this->success.begin(); _iter617 != this->success.end(); ++_iter617) + std::vector<PartitionSpec> ::const_iterator _iter623; + for (_iter623 = this->success.begin(); _iter623 != this->success.end(); ++_iter623) { - xfer += (*_iter617).write(oprot); + xfer += (*_iter623).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11369,14 +11369,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size618; - ::apache::thrift::protocol::TType _etype621; - xfer += iprot->readListBegin(_etype621, _size618); - (*(this->success)).resize(_size618); - uint32_t _i622; - for (_i622 = 0; _i622 < _size618; ++_i622) + uint32_t _size624; + ::apache::thrift::protocol::TType _etype627; + xfer += iprot->readListBegin(_etype627, _size624); + (*(this->success)).resize(_size624); + uint32_t _i628; + for (_i628 = 0; _i628 < _size624; ++_i628) { - xfer += (*(this->success))[_i622].read(iprot); + xfer += (*(this->success))[_i628].read(iprot); } xfer += iprot->readListEnd(); } @@ -11535,14 +11535,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size623; - ::apache::thrift::protocol::TType _etype626; - xfer += iprot->readListBegin(_etype626, _size623); - this->success.resize(_size623); - uint32_t _i627; - for (_i627 = 0; _i627 < _size623; ++_i627) + uint32_t _size629; + ::apache::thrift::protocol::TType _etype632; + xfer += iprot->readListBegin(_etype632, _size629); + this->success.resize(_size629); + uint32_t _i633; + for (_i633 = 0; _i633 < _size629; ++_i633) { - xfer += iprot->readString(this->success[_i627]); + xfer += iprot->readString(this->success[_i633]); } xfer += iprot->readListEnd(); } @@ -11581,10 +11581,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 _iter628; - for (_iter628 = this->success.begin(); _iter628 != this->success.end(); ++_iter628) + std::vector<std::string> ::const_iterator _iter634; + for (_iter634 = this->success.begin(); _iter634 != this->success.end(); ++_iter634) { - xfer += oprot->writeString((*_iter628)); + xfer += oprot->writeString((*_iter634)); } xfer += oprot->writeListEnd(); } @@ -11623,14 +11623,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size629; - ::apache::thrift::protocol::TType _etype632; - xfer += iprot->readListBegin(_etype632, _size629); - (*(this->success)).resize(_size629); - uint32_t _i633; - for (_i633 = 0; _i633 < _size629; ++_i633) + uint32_t _size635; + ::apache::thrift::protocol::TType _etype638; + xfer += iprot->readListBegin(_etype638, _size635); + (*(this->success)).resize(_size635); + uint32_t _i639; + for (_i639 = 0; _i639 < _size635; ++_i639) { - xfer += iprot->readString((*(this->success))[_i633]); + xfer += iprot->readString((*(this->success))[_i639]); } xfer += iprot->readListEnd(); } @@ -11699,14 +11699,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size634; - ::apache::thrift::protocol::TType _etype637; - xfer += iprot->readListBegin(_etype637, _size634); - this->part_vals.resize(_size634); - uint32_t _i638; - for (_i638 = 0; _i638 < _size634; ++_i638) + uint32_t _size640; + ::apache::thrift::protocol::TType _etype643; + xfer += iprot->readListBegin(_etype643, _size640); + this->part_vals.resize(_size640); + uint32_t _i644; + for (_i644 = 0; _i644 < _size640; ++_i644) { - xfer += iprot->readString(this->part_vals[_i638]); + xfer += iprot->readString(this->part_vals[_i644]); } xfer += iprot->readListEnd(); } @@ -11750,10 +11750,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 _iter639; - for (_iter639 = this->part_vals.begin(); _iter639 != this->part_vals.end(); ++_iter639) + std::vector<std::string> ::const_iterator _iter645; + for (_iter645 = this->part_vals.begin(); _iter645 != this->part_vals.end(); ++_iter645) { - xfer += oprot->writeString((*_iter639)); + xfer += oprot->writeString((*_iter645)); } xfer += oprot->writeListEnd(); } @@ -11783,10 +11783,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 _iter640; - for (_iter640 = (*(this->part_vals)).begin(); _iter640 != (*(this->part_vals)).end(); ++_iter640) + std::vector<std::string> ::const_iterator _iter646; + for (_iter646 = (*(this->part_vals)).begin(); _iter646 != (*(this->part_vals)).end(); ++_iter646) { - xfer += oprot->writeString((*_iter640)); + xfer += oprot->writeString((*_iter646)); } xfer += oprot->writeListEnd(); } @@ -11825,14 +11825,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - this->success.resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size647; + ::apache::thrift::protocol::TType _etype650; + xfer += iprot->readListBegin(_etype650, _size647); + this->success.resize(_size647); + uint32_t _i651; + for (_i651 = 0; _i651 < _size647; ++_i651) { - xfer += this->success[_i645].read(iprot); + xfer += this->success[_i651].read(iprot); } xfer += iprot->readListEnd(); } @@ -11879,10 +11879,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 _iter646; - for (_iter646 = this->success.begin(); _iter646 != this->success.end(); ++_iter646) + std::vector<Partition> ::const_iterator _iter652; + for (_iter652 = this->success.begin(); _iter652 != this->success.end(); ++_iter652) { - xfer += (*_iter646).write(oprot); + xfer += (*_iter652).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11925,14 +11925,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size647; - ::apache::thrift::protocol::TType _etype650; - xfer += iprot->readListBegin(_etype650, _size647); - (*(this->success)).resize(_size647); - uint32_t _i651; - for (_i651 = 0; _i651 < _size647; ++_i651) + uint32_t _size653; + ::apache::thrift::protocol::TType _etype656; + xfer += iprot->readListBegin(_etype656, _size653); + (*(this->success)).resize(_size653); + uint32_t _i657; + for (_i657 = 0; _i657 < _size653; ++_i657) { - xfer += (*(this->success))[_i651].read(iprot); + xfer += (*(this->success))[_i657].read(iprot); } xfer += iprot->readListEnd(); } @@ -12009,14 +12009,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size652; - ::apache::thrift::protocol::TType _etype655; - xfer += iprot->readListBegin(_etype655, _size652); - this->part_vals.resize(_size652); - uint32_t _i656; - for (_i656 = 0; _i656 < _size652; ++_i656) + uint32_t _size658; + ::apache::thrift::protocol::TType _etype661; + xfer += iprot->readListBegin(_etype661, _size658); + this->part_vals.resize(_size658); + uint32_t _i662; + for (_i662 = 0; _i662 < _size658; ++_i662) { - xfer += iprot->readString(this->part_vals[_i656]); + xfer += iprot->readString(this->part_vals[_i662]); } xfer += iprot->readListEnd(); } @@ -12045,14 +12045,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size657; - ::apache::thrift::protocol::TType _etype660; - xfer += iprot->readListBegin(_etype660, _size657); - this->group_names.resize(_size657); - uint32_t _i661; - for (_i661 = 0; _i661 < _size657; ++_i661) + uint32_t _size663; + ::apache::thrift::protocol::TType _etype666; + xfer += iprot->readListBegin(_etype666, _size663); + this->group_names.resize(_size663); + uint32_t _i667; + for (_i667 = 0; _i667 < _size663; ++_i667) { - xfer += iprot->readString(this->group_names[_i661]); + xfer += iprot->readString(this->group_names[_i667]); } xfer += iprot->readListEnd(); } @@ -12088,10 +12088,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 _iter662; - for (_iter662 = this->part_vals.begin(); _iter662 != this->part_vals.end(); ++_iter662) + std::vector<std::string> ::const_iterator _iter668; + for (_iter668 = this->part_vals.begin(); _iter668 != this->part_vals.end(); ++_iter668) { - xfer += oprot->writeString((*_iter662)); + xfer += oprot->writeString((*_iter668)); } xfer += oprot->writeListEnd(); } @@ -12108,10 +12108,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 _iter663; - for (_iter663 = this->group_names.begin(); _iter663 != this->group_names.end(); ++_iter663) + std::vector<std::string> ::const_iterator _iter669; + for (_iter669 = this->group_names.begin(); _iter669 != this->group_names.end(); ++_iter669) { - xfer += oprot->writeString((*_iter663)); + xfer += oprot->writeString((*_iter669)); } xfer += oprot->writeListEnd(); } @@ -12137,10 +12137,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 _iter664; - for (_iter664 = (*(this->part_vals)).begin(); _iter664 != (*(this->part_vals)).end(); ++_iter664) + std::vector<std::string> ::const_iterator _iter670; + for (_iter670 = (*(this->part_vals)).begin(); _iter670 != (*(this->part_vals)).end(); ++_iter670) { - xfer += oprot->writeString((*_iter664)); + xfer += oprot->writeString((*_iter670)); } xfer += oprot->writeListEnd(); } @@ -12157,10 +12157,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 _iter665; - for (_iter665 = (*(this->group_names)).begin(); _iter665 != (*(this->group_names)).end(); ++_iter665) + std::vector<std::string> ::const_iterator _iter671; + for (_iter671 = (*(this->group_names)).begin(); _iter671 != (*(this->group_names)).end(); ++_iter671) { - xfer += oprot->writeString((*_iter665)); + xfer += oprot->writeString((*_iter671)); } xfer += oprot->writeListEnd(); } @@ -12195,14 +12195,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size666; - ::apache::thrift::protocol::TType _etype669; - xfer += iprot->readListBegin(_etype669, _size666); - this->success.resize(_size666); - uint32_t _i670; - for (_i670 = 0; _i670 < _size666; ++_i670) + uint32_t _size672; + ::apache::thrift::protocol::TType _etype675; + xfer += iprot->readListBegin(_etype675, _size672); + this->success.resize(_size672); + uint32_t _i676; + for (_i676 = 0; _i676 < _size672; ++_i676) { - xfer += this->success[_i670].read(iprot); + xfer += this->success[_i676].read(iprot); } xfer += iprot->readListEnd(); } @@ -12249,10 +12249,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 _iter671; - for (_iter671 = this->success.begin(); _iter671 != this->success.end(); ++_iter671) + std::vector<Partition> ::const_iterator _iter677; + for (_iter677 = this->success.begin(); _iter677 != this->success.end(); ++_iter677) { - xfer += (*_iter671).write(oprot); + xfer += (*_iter677).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12295,14 +12295,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size672; - ::apache::thrift::protocol::TType _etype675; - xfer += iprot->readListBegin(_etype675, _size672); - (*(this->success)).resize(_size672); - uint32_t _i676; - for (_i676 = 0; _i676 < _size672; ++_i676) + uint32_t _size678; + ::apache::thrift::protocol::TType _etype681; + xfer += iprot->readListBegin(_etype681, _size678); + (*(this->success)).resize(_size678); + uint32_t _i682; + for (_i682 = 0; _i682 < _size678; ++_i682) { - xfer += (*(this->success))[_i676].read(iprot); + xfer += (*(this->success))[_i682].read(iprot); } xfer += iprot->readListEnd(); } @@ -12379,14 +12379,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size677; - ::apache::thrift::protocol::TType _etype680; - xfer += iprot->readListBegin(_etype680, _size677); - this->part_vals.resize(_size677); - uint32_t _i681; - for (_i681 = 0; _i681 < _size677; ++_i681) + uint32_t _size683; + ::apache::thrift::protocol::TType _etype686; + xfer += iprot->readListBegin(_etype686, _size683); + this->part_vals.resize(_size683); + uint32_t _i687; + for (_i687 = 0; _i687 < _size683; ++_i687) { - xfer += iprot->readString(this->part_vals[_i681]); + xfer += iprot->readString(this->part_vals[_i687]); } xfer += iprot->readListEnd(); } @@ -12430,10 +12430,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 _iter682; - for (_iter682 = this->part_vals.begin(); _iter682 != this->part_vals.end(); ++_iter682) + std::vector<std::string> ::const_iterator _iter688; + for (_iter688 = this->part_vals.begin(); _iter688 != this->part_vals.end(); ++_iter688) { - xfer += oprot->writeString((*_iter682)); + xfer += oprot->writeString((*_iter688)); } xfer += oprot->writeListEnd(); } @@ -12463,10 +12463,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 _iter683; - for (_iter683 = (*(this->part_vals)).begin(); _iter683 != (*(this->part_vals)).end(); ++_iter683) + std::vector<std::string> ::const_iterator _iter689; + for (_iter689 = (*(this->part_vals)).begin(); _iter689 != (*(this->part_vals)).end(); ++_iter689) { - xfer += oprot->writeString((*_iter683)); + xfer += oprot->writeString((*_iter689)); } xfer += oprot->writeListEnd(); } @@ -12505,14 +12505,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size684; - ::apache::thrift::protocol::TType _etype687; - xfer += iprot->readListBegin(_etype687, _size684); - this->success.resize(_size684); - uint32_t _i688; - for (_i688 = 0; _i688 < _size684; ++_i688) + uint32_t _size690; + ::apache::thrift::protocol::TType _etype693; + xfer += iprot->readListBegin(_etype693, _size690); + this->success.resize(_size690); + uint32_t _i694; + for (_i694 = 0; _i694 < _size690; ++_i694) { - xfer += iprot->readString(this->success[_i688]); + xfer += iprot->readString(this->success[_i694]); } xfer += iprot->readListEnd(); } @@ -12559,10 +12559,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 _iter689; - for (_iter689 = this->success.begin(); _iter689 != this->success.end(); ++_iter689) + std::vector<std::string> ::const_iterator _iter695; + for (_iter695 = this->success.begin(); _iter695 != this->success.end(); ++_iter695) { - xfer += oprot->writeString((*_iter689)); + xfer += oprot->writeString((*_iter695)); } xfer += oprot->writeListEnd(); } @@ -12605,14 +12605,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - (*(this->success)).resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size696; + ::apache::thrift::protocol::TType _etype699; + xfer += iprot->readListBegin(_etype699, _size696); + (*(this->success)).resize(_size696); + uint32_t _i700; + for (_i700 = 0; _i700 < _size696; ++_i700) { - xfer += iprot->readString((*(this->success))[_i694]); + xfer += iprot->readString((*(this->success))[_i700]); } xfer += iprot->readListEnd(); } @@ -12787,14 +12787,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size695; - ::apache::thrift::protocol::TType _etype698; - xfer += iprot->readListBegin(_etype698, _size695); - this->success.resize(_size695); - uint32_t _i699; - for (_i699 = 0; _i699 < _size695; ++_i699) + uint32_t _size701; + ::apache::thrift::protocol::TType _etype704; + xfer += iprot->readListBegin(_etype704, _size701); + this->success.resize(_size701); + uint32_t _i705; + for (_i705 = 0; _i705 < _size701; ++_i705) { - xfer += this->success[_i699].read(iprot); + xfer += this->success[_i705].read(iprot); } xfer += iprot->readListEnd(); } @@ -12841,10 +12841,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 _iter700; - for (_iter700 = this->success.begin(); _iter700 != this->success.end(); ++_iter700) + std::vector<Partition> ::const_iterator _iter706; + for (_iter706 = this->success.begin(); _iter706 != this->success.end(); ++_iter706) { - xfer += (*_iter700).write(oprot); + xfer += (*_iter706).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12887,14 +12887,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size701; - ::apache::thrift::protocol::TType _etype704; - xfer += iprot->readListBegin(_etype704, _size701); - (*(this->success)).resize(_size701); - uint32_t _i705; - for (_i705 = 0; _i705 < _size701; ++_i705) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readListBegin(_etype710, _size707); + (*(this->success)).resize(_size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - xfer += (*(this->success))[_i705].read(iprot); + xfer += (*(this->success))[_i711].read(iprot); } xfer += iprot->readListEnd(); } @@ -13069,14 +13069,14 @@ uint32_t ThriftHiveMetastore_get_part_sp if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size706; - ::apache::thrift::protocol::TType _etype709; - xfer += iprot->readListBegin(_etype709, _size706); - this->success.resize(_size706); - uint32_t _i710; - for (_i710 = 0; _i710 < _size706; ++_i710) + uint32_t _size712; + ::apache::thrift::protocol::TType _etype715; + xfer += iprot->readListBegin(_etype715, _size712); + this->success.resize(_size712); + uint32_t _i716; + for (_i716 = 0; _i716 < _size712; ++_i716) { - xfer += this->success[_i710].read(iprot); + xfer += this->success[_i716].read(iprot); } xfer += iprot->readListEnd(); } @@ -13123,10 +13123,10 @@ uint32_t ThriftHiveMetastore_get_part_sp 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 _iter711; - for (_iter711 = this->success.begin(); _iter711 != this->success.end(); ++_iter711) + std::vector<PartitionSpec> ::const_iterator _iter717; + for (_iter717 = this->success.begin(); _iter717 != this->success.end(); ++_iter717) { - xfer += (*_iter711).write(oprot); + xfer += (*_iter717).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13169,14 +13169,14 @@ uint32_t ThriftHiveMetastore_get_part_sp if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size712; - ::apache::thrift::protocol::TType _etype715; - xfer += iprot->readListBegin(_etype715, _size712); - (*(this->success)).resize(_size712); - uint32_t _i716; - for (_i716 = 0; _i716 < _size712; ++_i716) + uint32_t _size718; + ::apache::thrift::protocol::TType _etype721; + xfer += iprot->readListBegin(_etype721, _size718); + (*(this->success)).resize(_size718); + uint32_t _i722; + for (_i722 = 0; _i722 < _size718; ++_i722) { - xfer += (*(this->success))[_i716].read(iprot); + xfer += (*(this->success))[_i722].read(iprot); } xfer += iprot->readListEnd(); } @@ -13455,14 +13455,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size717; - ::apache::thrift::protocol::TType _etype720; - xfer += iprot->readListBegin(_etype720, _size717); - this->names.resize(_size717); - uint32_t _i721; - for (_i721 = 0; _i721 < _size717; ++_i721) + uint32_t _size723; + ::apache::thrift::protocol::TType _etype726; + xfer += iprot->readListBegin(_etype726, _size723); + this->names.resize(_size723); + uint32_t _i727; + for (_i727 = 0; _i727 < _size723; ++_i727) { - xfer += iprot->readString(this->names[_i721]); + xfer += iprot->readString(this->names[_i727]); } xfer += iprot->readListEnd(); }
[... 1631 lines stripped ...]
