Modified: hive/branches/spark/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp URL: http://svn.apache.org/viewvc/hive/branches/spark/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1613740&r1=1613739&r2=1613740&view=diff ============================================================================== --- hive/branches/spark/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original) +++ hive/branches/spark/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Sat Jul 26 23:45:46 2014 @@ -736,14 +736,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _etype362; - xfer += iprot->readListBegin(_etype362, _size359); - this->success.resize(_size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + 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[_i363]); + 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 _iter364; - for (_iter364 = this->success.begin(); _iter364 != this->success.end(); ++_iter364) + std::vector<std::string> ::const_iterator _iter368; + for (_iter368 = this->success.begin(); _iter368 != this->success.end(); ++_iter368) { - xfer += oprot->writeString((*_iter364)); + 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 _size365; - ::apache::thrift::protocol::TType _etype368; - xfer += iprot->readListBegin(_etype368, _size365); - (*(this->success)).resize(_size365); - uint32_t _i369; - for (_i369 = 0; _i369 < _size365; ++_i369) + 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))[_i369]); + 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 _size370; - ::apache::thrift::protocol::TType _etype373; - xfer += iprot->readListBegin(_etype373, _size370); - this->success.resize(_size370); - uint32_t _i374; - for (_i374 = 0; _i374 < _size370; ++_i374) + 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[_i374]); + 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 _iter375; - for (_iter375 = this->success.begin(); _iter375 != this->success.end(); ++_iter375) + std::vector<std::string> ::const_iterator _iter379; + for (_iter379 = this->success.begin(); _iter379 != this->success.end(); ++_iter379) { - xfer += oprot->writeString((*_iter375)); + 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 _size376; - ::apache::thrift::protocol::TType _etype379; - xfer += iprot->readListBegin(_etype379, _size376); - (*(this->success)).resize(_size376); - uint32_t _i380; - for (_i380 = 0; _i380 < _size376; ++_i380) + 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))[_i380]); + 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 _size381; - ::apache::thrift::protocol::TType _ktype382; - ::apache::thrift::protocol::TType _vtype383; - xfer += iprot->readMapBegin(_ktype382, _vtype383, _size381); - uint32_t _i385; - for (_i385 = 0; _i385 < _size381; ++_i385) + 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 _key386; - xfer += iprot->readString(_key386); - Type& _val387 = this->success[_key386]; - xfer += _val387.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 _iter388; - for (_iter388 = this->success.begin(); _iter388 != this->success.end(); ++_iter388) + std::map<std::string, Type> ::const_iterator _iter392; + for (_iter392 = this->success.begin(); _iter392 != this->success.end(); ++_iter392) { - xfer += oprot->writeString(_iter388->first); - xfer += _iter388->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 _size389; - ::apache::thrift::protocol::TType _ktype390; - ::apache::thrift::protocol::TType _vtype391; - xfer += iprot->readMapBegin(_ktype390, _vtype391, _size389); - uint32_t _i393; - for (_i393 = 0; _i393 < _size389; ++_i393) + 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 _key394; - xfer += iprot->readString(_key394); - Type& _val395 = (*(this->success))[_key394]; - xfer += _val395.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 _size396; - ::apache::thrift::protocol::TType _etype399; - xfer += iprot->readListBegin(_etype399, _size396); - this->success.resize(_size396); - uint32_t _i400; - for (_i400 = 0; _i400 < _size396; ++_i400) + 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[_i400].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 _iter401; - for (_iter401 = this->success.begin(); _iter401 != this->success.end(); ++_iter401) + std::vector<FieldSchema> ::const_iterator _iter405; + for (_iter405 = this->success.begin(); _iter405 != this->success.end(); ++_iter405) { - xfer += (*_iter401).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 _size402; - ::apache::thrift::protocol::TType _etype405; - xfer += iprot->readListBegin(_etype405, _size402); - (*(this->success)).resize(_size402); - uint32_t _i406; - for (_i406 = 0; _i406 < _size402; ++_i406) + 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))[_i406].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 _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 _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[_i411].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 _iter412; - for (_iter412 = this->success.begin(); _iter412 != this->success.end(); ++_iter412) + std::vector<FieldSchema> ::const_iterator _iter416; + for (_iter416 = this->success.begin(); _iter416 != this->success.end(); ++_iter416) { - xfer += (*_iter412).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 _size413; - ::apache::thrift::protocol::TType _etype416; - xfer += iprot->readListBegin(_etype416, _size413); - (*(this->success)).resize(_size413); - uint32_t _i417; - for (_i417 = 0; _i417 < _size413; ++_i417) + 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))[_i417].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 _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 _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[_i422]); + 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 _iter423; - for (_iter423 = this->success.begin(); _iter423 != this->success.end(); ++_iter423) + std::vector<std::string> ::const_iterator _iter427; + for (_iter427 = this->success.begin(); _iter427 != this->success.end(); ++_iter427) { - xfer += oprot->writeString((*_iter423)); + 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 _size424; - ::apache::thrift::protocol::TType _etype427; - xfer += iprot->readListBegin(_etype427, _size424); - (*(this->success)).resize(_size424); - uint32_t _i428; - for (_i428 = 0; _i428 < _size424; ++_i428) + 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))[_i428]); + 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 _size429; - ::apache::thrift::protocol::TType _etype432; - xfer += iprot->readListBegin(_etype432, _size429); - this->success.resize(_size429); - uint32_t _i433; - for (_i433 = 0; _i433 < _size429; ++_i433) + 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[_i433]); + 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 _iter434; - for (_iter434 = this->success.begin(); _iter434 != this->success.end(); ++_iter434) + std::vector<std::string> ::const_iterator _iter438; + for (_iter438 = this->success.begin(); _iter438 != this->success.end(); ++_iter438) { - xfer += oprot->writeString((*_iter434)); + 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 _size435; - ::apache::thrift::protocol::TType _etype438; - xfer += iprot->readListBegin(_etype438, _size435); - (*(this->success)).resize(_size435); - uint32_t _i439; - for (_i439 = 0; _i439 < _size435; ++_i439) + 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))[_i439]); + 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 _size440; - ::apache::thrift::protocol::TType _etype443; - xfer += iprot->readListBegin(_etype443, _size440); - this->tbl_names.resize(_size440); - uint32_t _i444; - for (_i444 = 0; _i444 < _size440; ++_i444) + 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[_i444]); + 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 _iter445; - for (_iter445 = this->tbl_names.begin(); _iter445 != this->tbl_names.end(); ++_iter445) + std::vector<std::string> ::const_iterator _iter449; + for (_iter449 = this->tbl_names.begin(); _iter449 != this->tbl_names.end(); ++_iter449) { - xfer += oprot->writeString((*_iter445)); + 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 _iter446; - for (_iter446 = (*(this->tbl_names)).begin(); _iter446 != (*(this->tbl_names)).end(); ++_iter446) + std::vector<std::string> ::const_iterator _iter450; + for (_iter450 = (*(this->tbl_names)).begin(); _iter450 != (*(this->tbl_names)).end(); ++_iter450) { - xfer += oprot->writeString((*_iter446)); + 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 _size447; - ::apache::thrift::protocol::TType _etype450; - xfer += iprot->readListBegin(_etype450, _size447); - this->success.resize(_size447); - uint32_t _i451; - for (_i451 = 0; _i451 < _size447; ++_i451) + 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[_i451].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 _iter452; - for (_iter452 = this->success.begin(); _iter452 != this->success.end(); ++_iter452) + std::vector<Table> ::const_iterator _iter456; + for (_iter456 = this->success.begin(); _iter456 != this->success.end(); ++_iter456) { - xfer += (*_iter452).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 _size453; - ::apache::thrift::protocol::TType _etype456; - xfer += iprot->readListBegin(_etype456, _size453); - (*(this->success)).resize(_size453); - uint32_t _i457; - for (_i457 = 0; _i457 < _size453; ++_i457) + 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))[_i457].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 _size458; - ::apache::thrift::protocol::TType _etype461; - xfer += iprot->readListBegin(_etype461, _size458); - this->success.resize(_size458); - uint32_t _i462; - for (_i462 = 0; _i462 < _size458; ++_i462) + 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[_i462]); + 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 _iter463; - for (_iter463 = this->success.begin(); _iter463 != this->success.end(); ++_iter463) + std::vector<std::string> ::const_iterator _iter467; + for (_iter467 = this->success.begin(); _iter467 != this->success.end(); ++_iter467) { - xfer += oprot->writeString((*_iter463)); + 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 _size464; - ::apache::thrift::protocol::TType _etype467; - xfer += iprot->readListBegin(_etype467, _size464); - (*(this->success)).resize(_size464); - uint32_t _i468; - for (_i468 = 0; _i468 < _size464; ++_i468) + 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))[_i468]); + 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 _size469; - ::apache::thrift::protocol::TType _etype472; - xfer += iprot->readListBegin(_etype472, _size469); - this->new_parts.resize(_size469); - uint32_t _i473; - for (_i473 = 0; _i473 < _size469; ++_i473) + 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[_i473].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 _iter474; - for (_iter474 = this->new_parts.begin(); _iter474 != this->new_parts.end(); ++_iter474) + std::vector<Partition> ::const_iterator _iter478; + for (_iter478 = this->new_parts.begin(); _iter478 != this->new_parts.end(); ++_iter478) { - xfer += (*_iter474).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 _iter475; - for (_iter475 = (*(this->new_parts)).begin(); _iter475 != (*(this->new_parts)).end(); ++_iter475) + std::vector<Partition> ::const_iterator _iter479; + for (_iter479 = (*(this->new_parts)).begin(); _iter479 != (*(this->new_parts)).end(); ++_iter479) { - xfer += (*_iter475).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 _size476; - ::apache::thrift::protocol::TType _etype479; - xfer += iprot->readListBegin(_etype479, _size476); - this->part_vals.resize(_size476); - uint32_t _i480; - for (_i480 = 0; _i480 < _size476; ++_i480) + 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[_i480]); + 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 _iter481; - for (_iter481 = this->part_vals.begin(); _iter481 != this->part_vals.end(); ++_iter481) + std::vector<std::string> ::const_iterator _iter485; + for (_iter485 = this->part_vals.begin(); _iter485 != this->part_vals.end(); ++_iter485) { - xfer += oprot->writeString((*_iter481)); + 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 _iter482; - for (_iter482 = (*(this->part_vals)).begin(); _iter482 != (*(this->part_vals)).end(); ++_iter482) + std::vector<std::string> ::const_iterator _iter486; + for (_iter486 = (*(this->part_vals)).begin(); _iter486 != (*(this->part_vals)).end(); ++_iter486) { - xfer += oprot->writeString((*_iter482)); + 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 _size483; - ::apache::thrift::protocol::TType _etype486; - xfer += iprot->readListBegin(_etype486, _size483); - this->part_vals.resize(_size483); - uint32_t _i487; - for (_i487 = 0; _i487 < _size483; ++_i487) + 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[_i487]); + 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 _iter488; - for (_iter488 = this->part_vals.begin(); _iter488 != this->part_vals.end(); ++_iter488) + std::vector<std::string> ::const_iterator _iter492; + for (_iter492 = this->part_vals.begin(); _iter492 != this->part_vals.end(); ++_iter492) { - xfer += oprot->writeString((*_iter488)); + 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 _iter489; - for (_iter489 = (*(this->part_vals)).begin(); _iter489 != (*(this->part_vals)).end(); ++_iter489) + std::vector<std::string> ::const_iterator _iter493; + for (_iter493 = (*(this->part_vals)).begin(); _iter493 != (*(this->part_vals)).end(); ++_iter493) { - xfer += oprot->writeString((*_iter489)); + 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 _size490; - ::apache::thrift::protocol::TType _etype493; - xfer += iprot->readListBegin(_etype493, _size490); - this->part_vals.resize(_size490); - uint32_t _i494; - for (_i494 = 0; _i494 < _size490; ++_i494) + 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[_i494]); + 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 _iter495; - for (_iter495 = this->part_vals.begin(); _iter495 != this->part_vals.end(); ++_iter495) + std::vector<std::string> ::const_iterator _iter499; + for (_iter499 = this->part_vals.begin(); _iter499 != this->part_vals.end(); ++_iter499) { - xfer += oprot->writeString((*_iter495)); + 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 _iter496; - for (_iter496 = (*(this->part_vals)).begin(); _iter496 != (*(this->part_vals)).end(); ++_iter496) + std::vector<std::string> ::const_iterator _iter500; + for (_iter500 = (*(this->part_vals)).begin(); _iter500 != (*(this->part_vals)).end(); ++_iter500) { - xfer += oprot->writeString((*_iter496)); + 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 _size497; - ::apache::thrift::protocol::TType _etype500; - xfer += iprot->readListBegin(_etype500, _size497); - this->part_vals.resize(_size497); - uint32_t _i501; - for (_i501 = 0; _i501 < _size497; ++_i501) + 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[_i501]); + 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 _iter502; - for (_iter502 = this->part_vals.begin(); _iter502 != this->part_vals.end(); ++_iter502) + std::vector<std::string> ::const_iterator _iter506; + for (_iter506 = this->part_vals.begin(); _iter506 != this->part_vals.end(); ++_iter506) { - xfer += oprot->writeString((*_iter502)); + 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 _iter503; - for (_iter503 = (*(this->part_vals)).begin(); _iter503 != (*(this->part_vals)).end(); ++_iter503) + std::vector<std::string> ::const_iterator _iter507; + for (_iter507 = (*(this->part_vals)).begin(); _iter507 != (*(this->part_vals)).end(); ++_iter507) { - xfer += oprot->writeString((*_iter503)); + 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 _size504; - ::apache::thrift::protocol::TType _etype507; - xfer += iprot->readListBegin(_etype507, _size504); - this->part_vals.resize(_size504); - uint32_t _i508; - for (_i508 = 0; _i508 < _size504; ++_i508) + 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[_i508]); + 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 _iter509; - for (_iter509 = this->part_vals.begin(); _iter509 != this->part_vals.end(); ++_iter509) + std::vector<std::string> ::const_iterator _iter513; + for (_iter513 = this->part_vals.begin(); _iter513 != this->part_vals.end(); ++_iter513) { - xfer += oprot->writeString((*_iter509)); + 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 _iter510; - for (_iter510 = (*(this->part_vals)).begin(); _iter510 != (*(this->part_vals)).end(); ++_iter510) + std::vector<std::string> ::const_iterator _iter514; + for (_iter514 = (*(this->part_vals)).begin(); _iter514 != (*(this->part_vals)).end(); ++_iter514) { - xfer += oprot->writeString((*_iter510)); + 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 _size511; - ::apache::thrift::protocol::TType _ktype512; - ::apache::thrift::protocol::TType _vtype513; - xfer += iprot->readMapBegin(_ktype512, _vtype513, _size511); - uint32_t _i515; - for (_i515 = 0; _i515 < _size511; ++_i515) + 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 _key516; - xfer += iprot->readString(_key516); - std::string& _val517 = this->partitionSpecs[_key516]; - xfer += iprot->readString(_val517); + 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 _iter518; - for (_iter518 = this->partitionSpecs.begin(); _iter518 != this->partitionSpecs.end(); ++_iter518) + std::map<std::string, std::string> ::const_iterator _iter522; + for (_iter522 = this->partitionSpecs.begin(); _iter522 != this->partitionSpecs.end(); ++_iter522) { - xfer += oprot->writeString(_iter518->first); - xfer += oprot->writeString(_iter518->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 _iter519; - for (_iter519 = (*(this->partitionSpecs)).begin(); _iter519 != (*(this->partitionSpecs)).end(); ++_iter519) + std::map<std::string, std::string> ::const_iterator _iter523; + for (_iter523 = (*(this->partitionSpecs)).begin(); _iter523 != (*(this->partitionSpecs)).end(); ++_iter523) { - xfer += oprot->writeString(_iter519->first); - xfer += oprot->writeString(_iter519->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 _size520; - ::apache::thrift::protocol::TType _etype523; - xfer += iprot->readListBegin(_etype523, _size520); - this->part_vals.resize(_size520); - uint32_t _i524; - for (_i524 = 0; _i524 < _size520; ++_i524) + 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[_i524]); + 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 _size525; - ::apache::thrift::protocol::TType _etype528; - xfer += iprot->readListBegin(_etype528, _size525); - this->group_names.resize(_size525); - uint32_t _i529; - for (_i529 = 0; _i529 < _size525; ++_i529) + 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[_i529]); + 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 _iter530; - for (_iter530 = this->part_vals.begin(); _iter530 != this->part_vals.end(); ++_iter530) + std::vector<std::string> ::const_iterator _iter534; + for (_iter534 = this->part_vals.begin(); _iter534 != this->part_vals.end(); ++_iter534) { - xfer += oprot->writeString((*_iter530)); + 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 _iter531; - for (_iter531 = this->group_names.begin(); _iter531 != this->group_names.end(); ++_iter531) + std::vector<std::string> ::const_iterator _iter535; + for (_iter535 = this->group_names.begin(); _iter535 != this->group_names.end(); ++_iter535) { - xfer += oprot->writeString((*_iter531)); + 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 _iter532; - for (_iter532 = (*(this->part_vals)).begin(); _iter532 != (*(this->part_vals)).end(); ++_iter532) + std::vector<std::string> ::const_iterator _iter536; + for (_iter536 = (*(this->part_vals)).begin(); _iter536 != (*(this->part_vals)).end(); ++_iter536) { - xfer += oprot->writeString((*_iter532)); + 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 _iter533; - for (_iter533 = (*(this->group_names)).begin(); _iter533 != (*(this->group_names)).end(); ++_iter533) + std::vector<std::string> ::const_iterator _iter537; + for (_iter537 = (*(this->group_names)).begin(); _iter537 != (*(this->group_names)).end(); ++_iter537) { - xfer += oprot->writeString((*_iter533)); + 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 _size534; - ::apache::thrift::protocol::TType _etype537; - xfer += iprot->readListBegin(_etype537, _size534); - this->success.resize(_size534); - uint32_t _i538; - for (_i538 = 0; _i538 < _size534; ++_i538) + 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[_i538].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 _iter539; - for (_iter539 = this->success.begin(); _iter539 != this->success.end(); ++_iter539) + std::vector<Partition> ::const_iterator _iter543; + for (_iter543 = this->success.begin(); _iter543 != this->success.end(); ++_iter543) { - xfer += (*_iter539).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 _size540; - ::apache::thrift::protocol::TType _etype543; - xfer += iprot->readListBegin(_etype543, _size540); - (*(this->success)).resize(_size540); - uint32_t _i544; - for (_i544 = 0; _i544 < _size540; ++_i544) + 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))[_i544].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 _size545; - ::apache::thrift::protocol::TType _etype548; - xfer += iprot->readListBegin(_etype548, _size545); - this->group_names.resize(_size545); - uint32_t _i549; - for (_i549 = 0; _i549 < _size545; ++_i549) + 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[_i549]); + 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 _iter550; - for (_iter550 = this->group_names.begin(); _iter550 != this->group_names.end(); ++_iter550) + std::vector<std::string> ::const_iterator _iter554; + for (_iter554 = this->group_names.begin(); _iter554 != this->group_names.end(); ++_iter554) { - xfer += oprot->writeString((*_iter550)); + 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 _iter551; - for (_iter551 = (*(this->group_names)).begin(); _iter551 != (*(this->group_names)).end(); ++_iter551) + std::vector<std::string> ::const_iterator _iter555; + for (_iter555 = (*(this->group_names)).begin(); _iter555 != (*(this->group_names)).end(); ++_iter555) { - xfer += oprot->writeString((*_iter551)); + 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 _size552; - ::apache::thrift::protocol::TType _etype555; - xfer += iprot->readListBegin(_etype555, _size552); - this->success.resize(_size552); - uint32_t _i556; - for (_i556 = 0; _i556 < _size552; ++_i556) + 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[_i556].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 _iter557; - for (_iter557 = this->success.begin(); _iter557 != this->success.end(); ++_iter557) + std::vector<Partition> ::const_iterator _iter561; + for (_iter561 = this->success.begin(); _iter561 != this->success.end(); ++_iter561) { - xfer += (*_iter557).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 _size558; - ::apache::thrift::protocol::TType _etype561; - xfer += iprot->readListBegin(_etype561, _size558); - (*(this->success)).resize(_size558); - uint32_t _i562; - for (_i562 = 0; _i562 < _size558; ++_i562) + 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))[_i562].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 _size563; - ::apache::thrift::protocol::TType _etype566; - xfer += iprot->readListBegin(_etype566, _size563); - this->success.resize(_size563); - uint32_t _i567; - for (_i567 = 0; _i567 < _size563; ++_i567) + 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[_i567]); + 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 _iter568; - for (_iter568 = this->success.begin(); _iter568 != this->success.end(); ++_iter568) + std::vector<std::string> ::const_iterator _iter572; + for (_iter572 = this->success.begin(); _iter572 != this->success.end(); ++_iter572) { - xfer += oprot->writeString((*_iter568)); + 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 _size569; - ::apache::thrift::protocol::TType _etype572; - xfer += iprot->readListBegin(_etype572, _size569); - (*(this->success)).resize(_size569); - uint32_t _i573; - for (_i573 = 0; _i573 < _size569; ++_i573) + 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))[_i573]); + 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 _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - this->part_vals.resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + 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[_i578]); + 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 _iter579; - for (_iter579 = this->part_vals.begin(); _iter579 != this->part_vals.end(); ++_iter579) + std::vector<std::string> ::const_iterator _iter583; + for (_iter583 = this->part_vals.begin(); _iter583 != this->part_vals.end(); ++_iter583) { - xfer += oprot->writeString((*_iter579)); + 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 _iter580; - for (_iter580 = (*(this->part_vals)).begin(); _iter580 != (*(this->part_vals)).end(); ++_iter580) + std::vector<std::string> ::const_iterator _iter584; + for (_iter584 = (*(this->part_vals)).begin(); _iter584 != (*(this->part_vals)).end(); ++_iter584) { - xfer += oprot->writeString((*_iter580)); + 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 _size581; - ::apache::thrift::protocol::TType _etype584; - xfer += iprot->readListBegin(_etype584, _size581); - this->success.resize(_size581); - uint32_t _i585; - for (_i585 = 0; _i585 < _size581; ++_i585) + 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[_i585].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 _iter586; - for (_iter586 = this->success.begin(); _iter586 != this->success.end(); ++_iter586) + std::vector<Partition> ::const_iterator _iter590; + for (_iter590 = this->success.begin(); _iter590 != this->success.end(); ++_iter590) { - xfer += (*_iter586).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 _size587; - ::apache::thrift::protocol::TType _etype590; - xfer += iprot->readListBegin(_etype590, _size587); - (*(this->success)).resize(_size587); - uint32_t _i591; - for (_i591 = 0; _i591 < _size587; ++_i591) + 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))[_i591].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 _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readListBegin(_etype595, _size592); - this->part_vals.resize(_size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + 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[_i596]); + 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 _size597; - ::apache::thrift::protocol::TType _etype600; - xfer += iprot->readListBegin(_etype600, _size597); - this->group_names.resize(_size597); - uint32_t _i601; - for (_i601 = 0; _i601 < _size597; ++_i601) + 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[_i601]); + 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 _iter602; - for (_iter602 = this->part_vals.begin(); _iter602 != this->part_vals.end(); ++_iter602) + std::vector<std::string> ::const_iterator _iter606; + for (_iter606 = this->part_vals.begin(); _iter606 != this->part_vals.end(); ++_iter606) { - xfer += oprot->writeString((*_iter602)); + 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 _iter603; - for (_iter603 = this->group_names.begin(); _iter603 != this->group_names.end(); ++_iter603) + std::vector<std::string> ::const_iterator _iter607; + for (_iter607 = this->group_names.begin(); _iter607 != this->group_names.end(); ++_iter607) { - xfer += oprot->writeString((*_iter603)); + 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 _iter604; - for (_iter604 = (*(this->part_vals)).begin(); _iter604 != (*(this->part_vals)).end(); ++_iter604) + std::vector<std::string> ::const_iterator _iter608; + for (_iter608 = (*(this->part_vals)).begin(); _iter608 != (*(this->part_vals)).end(); ++_iter608) { - xfer += oprot->writeString((*_iter604)); + 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 _iter605; - for (_iter605 = (*(this->group_names)).begin(); _iter605 != (*(this->group_names)).end(); ++_iter605) + std::vector<std::string> ::const_iterator _iter609; + for (_iter609 = (*(this->group_names)).begin(); _iter609 != (*(this->group_names)).end(); ++_iter609) { - xfer += oprot->writeString((*_iter605)); + 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 _size606; - ::apache::thrift::protocol::TType _etype609; - xfer += iprot->readListBegin(_etype609, _size606); - this->success.resize(_size606); - uint32_t _i610; - for (_i610 = 0; _i610 < _size606; ++_i610) + 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[_i610].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 _iter611; - for (_iter611 = this->success.begin(); _iter611 != this->success.end(); ++_iter611) + std::vector<Partition> ::const_iterator _iter615; + for (_iter615 = this->success.begin(); _iter615 != this->success.end(); ++_iter615) { - xfer += (*_iter611).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 _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 _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))[_i616].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 _size617; - ::apache::thrift::protocol::TType _etype620; - xfer += iprot->readListBegin(_etype620, _size617); - this->part_vals.resize(_size617); - uint32_t _i621; - for (_i621 = 0; _i621 < _size617; ++_i621) + 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[_i621]); + 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 _iter622; - for (_iter622 = this->part_vals.begin(); _iter622 != this->part_vals.end(); ++_iter622) + std::vector<std::string> ::const_iterator _iter626; + for (_iter626 = this->part_vals.begin(); _iter626 != this->part_vals.end(); ++_iter626) { - xfer += oprot->writeString((*_iter622)); + 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 _iter623; - for (_iter623 = (*(this->part_vals)).begin(); _iter623 != (*(this->part_vals)).end(); ++_iter623) + std::vector<std::string> ::const_iterator _iter627; + for (_iter627 = (*(this->part_vals)).begin(); _iter627 != (*(this->part_vals)).end(); ++_iter627) { - xfer += oprot->writeString((*_iter623)); + 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 _size624; - ::apache::thrift::protocol::TType _etype627; - xfer += iprot->readListBegin(_etype627, _size624); - this->success.resize(_size624); - uint32_t _i628; - for (_i628 = 0; _i628 < _size624; ++_i628) + 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[_i628]); + 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 _iter629; - for (_iter629 = this->success.begin(); _iter629 != this->success.end(); ++_iter629) + std::vector<std::string> ::const_iterator _iter633; + for (_iter633 = this->success.begin(); _iter633 != this->success.end(); ++_iter633) { - xfer += oprot->writeString((*_iter629)); + 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 _size630; - ::apache::thrift::protocol::TType _etype633; - xfer += iprot->readListBegin(_etype633, _size630); - (*(this->success)).resize(_size630); - uint32_t _i634; - for (_i634 = 0; _i634 < _size630; ++_i634) + 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))[_i634]); + 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 _size635; - ::apache::thrift::protocol::TType _etype638; - xfer += iprot->readListBegin(_etype638, _size635); - this->success.resize(_size635); - uint32_t _i639; - for (_i639 = 0; _i639 < _size635; ++_i639) + 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[_i639].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 _iter640; - for (_iter640 = this->success.begin(); _iter640 != this->success.end(); ++_iter640) + std::vector<Partition> ::const_iterator _iter644; + for (_iter644 = this->success.begin(); _iter644 != this->success.end(); ++_iter644) { - xfer += (*_iter640).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 _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 _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))[_i645].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 _size646; - ::apache::thrift::protocol::TType _etype649; - xfer += iprot->readListBegin(_etype649, _size646); - this->names.resize(_size646); - uint32_t _i650; - for (_i650 = 0; _i650 < _size646; ++_i650) + 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[_i650]); + 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 _iter651; - for (_iter651 = this->names.begin(); _iter651 != this->names.end(); ++_iter651) + std::vector<std::string> ::const_iterator _iter655; + for (_iter655 = this->names.begin(); _iter655 != this->names.end(); ++_iter655) { - xfer += oprot->writeString((*_iter651)); + 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 _iter652; - for (_iter652 = (*(this->names)).begin(); _iter652 != (*(this->names)).end(); ++_iter652) + std::vector<std::string> ::const_iterator _iter656; + for (_iter656 = (*(this->names)).begin(); _iter656 != (*(this->names)).end(); ++_iter656) { - xfer += oprot->writeString((*_iter652)); + 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 _size653; - ::apache::thrift::protocol::TType _etype656; - xfer += iprot->readListBegin(_etype656, _size653); - this->success.resize(_size653); - uint32_t _i657; - for (_i657 = 0; _i657 < _size653; ++_i657) + 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[_i657].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 _iter658; - for (_iter658 = this->success.begin(); _iter658 != this->success.end(); ++_iter658) + std::vector<Partition> ::const_iterator _iter662; + for (_iter662 = this->success.begin(); _iter662 != this->success.end(); ++_iter662) { - xfer += (*_iter658).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 _size659; - ::apache::thrift::protocol::TType _etype662; - xfer += iprot->readListBegin(_etype662, _size659); - (*(this->success)).resize(_size659); - uint32_t _i663; - for (_i663 = 0; _i663 < _size659; ++_i663) + 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))[_i663].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 _size664; - ::apache::thrift::protocol::TType _etype667; - xfer += iprot->readListBegin(_etype667, _size664); - this->new_parts.resize(_size664); - uint32_t _i668; - for (_i668 = 0; _i668 < _size664; ++_i668) + 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[_i668].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 _iter669; - for (_iter669 = this->new_parts.begin(); _iter669 != this->new_parts.end(); ++_iter669) + std::vector<Partition> ::const_iterator _iter673; + for (_iter673 = this->new_parts.begin(); _iter673 != this->new_parts.end(); ++_iter673) { - xfer += (*_iter669).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 _iter670; - for (_iter670 = (*(this->new_parts)).begin(); _iter670 != (*(this->new_parts)).end(); ++_iter670) + std::vector<Partition> ::const_iterator _iter674; + for (_iter674 = (*(this->new_parts)).begin(); _iter674 != (*(this->new_parts)).end(); ++_iter674) { - xfer += (*_iter670).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 _size671; - ::apache::thrift::protocol::TType _etype674; - xfer += iprot->readListBegin(_etype674, _size671); - this->part_vals.resize(_size671); - uint32_t _i675; - for (_i675 = 0; _i675 < _size671; ++_i675) + 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[_i675]); + 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()));
[... 1564 lines stripped ...]
