Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1622763&r1=1622762&r2=1622763&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Fri Sep 5 19:15:44 2014 @@ -1096,14 +1096,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size375; - ::apache::thrift::protocol::TType _etype378; - xfer += iprot->readListBegin(_etype378, _size375); - this->success.resize(_size375); - uint32_t _i379; - for (_i379 = 0; _i379 < _size375; ++_i379) + 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) { - xfer += iprot->readString(this->success[_i379]); + xfer += iprot->readString(this->success[_i405]); } 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 _iter380; - for (_iter380 = this->success.begin(); _iter380 != this->success.end(); ++_iter380) + std::vector<std::string> ::const_iterator _iter406; + for (_iter406 = this->success.begin(); _iter406 != this->success.end(); ++_iter406) { - xfer += oprot->writeString((*_iter380)); + xfer += oprot->writeString((*_iter406)); } xfer += oprot->writeListEnd(); } @@ -1184,14 +1184,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size381; - ::apache::thrift::protocol::TType _etype384; - xfer += iprot->readListBegin(_etype384, _size381); - (*(this->success)).resize(_size381); - uint32_t _i385; - for (_i385 = 0; _i385 < _size381; ++_i385) + 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))[_i385]); + xfer += iprot->readString((*(this->success))[_i411]); } 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 _size386; - ::apache::thrift::protocol::TType _etype389; - xfer += iprot->readListBegin(_etype389, _size386); - this->success.resize(_size386); - uint32_t _i390; - for (_i390 = 0; _i390 < _size386; ++_i390) + 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) { - xfer += iprot->readString(this->success[_i390]); + xfer += iprot->readString(this->success[_i416]); } 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 _iter391; - for (_iter391 = this->success.begin(); _iter391 != this->success.end(); ++_iter391) + std::vector<std::string> ::const_iterator _iter417; + for (_iter417 = this->success.begin(); _iter417 != this->success.end(); ++_iter417) { - xfer += oprot->writeString((*_iter391)); + xfer += oprot->writeString((*_iter417)); } 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 _size392; - ::apache::thrift::protocol::TType _etype395; - xfer += iprot->readListBegin(_etype395, _size392); - (*(this->success)).resize(_size392); - uint32_t _i396; - for (_i396 = 0; _i396 < _size392; ++_i396) + 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))[_i396]); + xfer += iprot->readString((*(this->success))[_i422]); } 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 _size397; - ::apache::thrift::protocol::TType _ktype398; - ::apache::thrift::protocol::TType _vtype399; - xfer += iprot->readMapBegin(_ktype398, _vtype399, _size397); - uint32_t _i401; - for (_i401 = 0; _i401 < _size397; ++_i401) + 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) { - std::string _key402; - xfer += iprot->readString(_key402); - Type& _val403 = this->success[_key402]; - xfer += _val403.read(iprot); + std::string _key428; + xfer += iprot->readString(_key428); + Type& _val429 = this->success[_key428]; + xfer += _val429.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 _iter404; - for (_iter404 = this->success.begin(); _iter404 != this->success.end(); ++_iter404) + std::map<std::string, Type> ::const_iterator _iter430; + for (_iter430 = this->success.begin(); _iter430 != this->success.end(); ++_iter430) { - xfer += oprot->writeString(_iter404->first); - xfer += _iter404->second.write(oprot); + xfer += oprot->writeString(_iter430->first); + xfer += _iter430->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 _size405; - ::apache::thrift::protocol::TType _ktype406; - ::apache::thrift::protocol::TType _vtype407; - xfer += iprot->readMapBegin(_ktype406, _vtype407, _size405); - uint32_t _i409; - for (_i409 = 0; _i409 < _size405; ++_i409) + 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) { - std::string _key410; - xfer += iprot->readString(_key410); - Type& _val411 = (*(this->success))[_key410]; - xfer += _val411.read(iprot); + std::string _key436; + xfer += iprot->readString(_key436); + Type& _val437 = (*(this->success))[_key436]; + xfer += _val437.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 _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 _size438; + ::apache::thrift::protocol::TType _etype441; + xfer += iprot->readListBegin(_etype441, _size438); + this->success.resize(_size438); + uint32_t _i442; + for (_i442 = 0; _i442 < _size438; ++_i442) { - xfer += this->success[_i416].read(iprot); + xfer += this->success[_i442].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 _iter417; - for (_iter417 = this->success.begin(); _iter417 != this->success.end(); ++_iter417) + std::vector<FieldSchema> ::const_iterator _iter443; + for (_iter443 = this->success.begin(); _iter443 != this->success.end(); ++_iter443) { - xfer += (*_iter417).write(oprot); + xfer += (*_iter443).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 _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 _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))[_i422].read(iprot); + xfer += (*(this->success))[_i448].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 _size423; - ::apache::thrift::protocol::TType _etype426; - xfer += iprot->readListBegin(_etype426, _size423); - this->success.resize(_size423); - uint32_t _i427; - for (_i427 = 0; _i427 < _size423; ++_i427) + 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) { - xfer += this->success[_i427].read(iprot); + xfer += this->success[_i453].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 _iter428; - for (_iter428 = this->success.begin(); _iter428 != this->success.end(); ++_iter428) + std::vector<FieldSchema> ::const_iterator _iter454; + for (_iter454 = this->success.begin(); _iter454 != this->success.end(); ++_iter454) { - xfer += (*_iter428).write(oprot); + xfer += (*_iter454).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 _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 _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))[_i433].read(iprot); + xfer += (*(this->success))[_i459].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 _size434; - ::apache::thrift::protocol::TType _etype437; - xfer += iprot->readListBegin(_etype437, _size434); - this->success.resize(_size434); - uint32_t _i438; - for (_i438 = 0; _i438 < _size434; ++_i438) + 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) { - xfer += iprot->readString(this->success[_i438]); + xfer += iprot->readString(this->success[_i464]); } 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 _iter439; - for (_iter439 = this->success.begin(); _iter439 != this->success.end(); ++_iter439) + std::vector<std::string> ::const_iterator _iter465; + for (_iter465 = this->success.begin(); _iter465 != this->success.end(); ++_iter465) { - xfer += oprot->writeString((*_iter439)); + xfer += oprot->writeString((*_iter465)); } xfer += oprot->writeListEnd(); } @@ -4096,14 +4096,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size440; - ::apache::thrift::protocol::TType _etype443; - xfer += iprot->readListBegin(_etype443, _size440); - (*(this->success)).resize(_size440); - uint32_t _i444; - for (_i444 = 0; _i444 < _size440; ++_i444) + 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))[_i444]); + xfer += iprot->readString((*(this->success))[_i470]); } 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 _size445; - ::apache::thrift::protocol::TType _etype448; - xfer += iprot->readListBegin(_etype448, _size445); - this->success.resize(_size445); - uint32_t _i449; - for (_i449 = 0; _i449 < _size445; ++_i449) + 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) { - xfer += iprot->readString(this->success[_i449]); + xfer += iprot->readString(this->success[_i475]); } 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 _iter450; - for (_iter450 = this->success.begin(); _iter450 != this->success.end(); ++_iter450) + std::vector<std::string> ::const_iterator _iter476; + for (_iter476 = this->success.begin(); _iter476 != this->success.end(); ++_iter476) { - xfer += oprot->writeString((*_iter450)); + xfer += oprot->writeString((*_iter476)); } 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 _size451; - ::apache::thrift::protocol::TType _etype454; - xfer += iprot->readListBegin(_etype454, _size451); - (*(this->success)).resize(_size451); - uint32_t _i455; - for (_i455 = 0; _i455 < _size451; ++_i455) + 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))[_i455]); + xfer += iprot->readString((*(this->success))[_i481]); } 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 _size456; - ::apache::thrift::protocol::TType _etype459; - xfer += iprot->readListBegin(_etype459, _size456); - this->tbl_names.resize(_size456); - uint32_t _i460; - for (_i460 = 0; _i460 < _size456; ++_i460) + 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) { - xfer += iprot->readString(this->tbl_names[_i460]); + xfer += iprot->readString(this->tbl_names[_i486]); } 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 _iter461; - for (_iter461 = this->tbl_names.begin(); _iter461 != this->tbl_names.end(); ++_iter461) + std::vector<std::string> ::const_iterator _iter487; + for (_iter487 = this->tbl_names.begin(); _iter487 != this->tbl_names.end(); ++_iter487) { - xfer += oprot->writeString((*_iter461)); + xfer += oprot->writeString((*_iter487)); } 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 _iter462; - for (_iter462 = (*(this->tbl_names)).begin(); _iter462 != (*(this->tbl_names)).end(); ++_iter462) + std::vector<std::string> ::const_iterator _iter488; + for (_iter488 = (*(this->tbl_names)).begin(); _iter488 != (*(this->tbl_names)).end(); ++_iter488) { - xfer += oprot->writeString((*_iter462)); + xfer += oprot->writeString((*_iter488)); } 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 _size463; - ::apache::thrift::protocol::TType _etype466; - xfer += iprot->readListBegin(_etype466, _size463); - this->success.resize(_size463); - uint32_t _i467; - for (_i467 = 0; _i467 < _size463; ++_i467) + 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) { - xfer += this->success[_i467].read(iprot); + xfer += this->success[_i493].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 _iter468; - for (_iter468 = this->success.begin(); _iter468 != this->success.end(); ++_iter468) + std::vector<Table> ::const_iterator _iter494; + for (_iter494 = this->success.begin(); _iter494 != this->success.end(); ++_iter494) { - xfer += (*_iter468).write(oprot); + xfer += (*_iter494).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 _size469; - ::apache::thrift::protocol::TType _etype472; - xfer += iprot->readListBegin(_etype472, _size469); - (*(this->success)).resize(_size469); - uint32_t _i473; - for (_i473 = 0; _i473 < _size469; ++_i473) + 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))[_i473].read(iprot); + xfer += (*(this->success))[_i499].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 _size474; - ::apache::thrift::protocol::TType _etype477; - xfer += iprot->readListBegin(_etype477, _size474); - this->success.resize(_size474); - uint32_t _i478; - for (_i478 = 0; _i478 < _size474; ++_i478) + 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) { - xfer += iprot->readString(this->success[_i478]); + xfer += iprot->readString(this->success[_i504]); } 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 _iter479; - for (_iter479 = this->success.begin(); _iter479 != this->success.end(); ++_iter479) + std::vector<std::string> ::const_iterator _iter505; + for (_iter505 = this->success.begin(); _iter505 != this->success.end(); ++_iter505) { - xfer += oprot->writeString((*_iter479)); + xfer += oprot->writeString((*_iter505)); } 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 _size480; - ::apache::thrift::protocol::TType _etype483; - xfer += iprot->readListBegin(_etype483, _size480); - (*(this->success)).resize(_size480); - uint32_t _i484; - for (_i484 = 0; _i484 < _size480; ++_i484) + 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))[_i484]); + xfer += iprot->readString((*(this->success))[_i510]); } xfer += iprot->readListEnd(); } @@ -6076,14 +6076,14 @@ uint32_t ThriftHiveMetastore_add_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size485; - ::apache::thrift::protocol::TType _etype488; - xfer += iprot->readListBegin(_etype488, _size485); - this->new_parts.resize(_size485); - uint32_t _i489; - for (_i489 = 0; _i489 < _size485; ++_i489) + 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) { - xfer += this->new_parts[_i489].read(iprot); + xfer += this->new_parts[_i515].read(iprot); } xfer += iprot->readListEnd(); } @@ -6111,10 +6111,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 _iter490; - for (_iter490 = this->new_parts.begin(); _iter490 != this->new_parts.end(); ++_iter490) + std::vector<Partition> ::const_iterator _iter516; + for (_iter516 = this->new_parts.begin(); _iter516 != this->new_parts.end(); ++_iter516) { - xfer += (*_iter490).write(oprot); + xfer += (*_iter516).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6132,10 +6132,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 _iter491; - for (_iter491 = (*(this->new_parts)).begin(); _iter491 != (*(this->new_parts)).end(); ++_iter491) + std::vector<Partition> ::const_iterator _iter517; + for (_iter517 = (*(this->new_parts)).begin(); _iter517 != (*(this->new_parts)).end(); ++_iter517) { - xfer += (*_iter491).write(oprot); + xfer += (*_iter517).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6302,6 +6302,256 @@ uint32_t ThriftHiveMetastore_add_partiti return xfer; } +uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + 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) + { + xfer += this->new_parts[_i522].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.new_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_args"); + + 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) + { + xfer += (*_iter523).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_pargs"); + + 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) + { + xfer += (*_iter524).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_partitions_pspec_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0); + xfer += oprot->writeI32(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_add_partitions_pspec_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; @@ -6342,14 +6592,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size492; - ::apache::thrift::protocol::TType _etype495; - xfer += iprot->readListBegin(_etype495, _size492); - this->part_vals.resize(_size492); - uint32_t _i496; - for (_i496 = 0; _i496 < _size492; ++_i496) + 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) { - xfer += iprot->readString(this->part_vals[_i496]); + xfer += iprot->readString(this->part_vals[_i529]); } xfer += iprot->readListEnd(); } @@ -6385,10 +6635,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 _iter497; - for (_iter497 = this->part_vals.begin(); _iter497 != this->part_vals.end(); ++_iter497) + std::vector<std::string> ::const_iterator _iter530; + for (_iter530 = this->part_vals.begin(); _iter530 != this->part_vals.end(); ++_iter530) { - xfer += oprot->writeString((*_iter497)); + xfer += oprot->writeString((*_iter530)); } xfer += oprot->writeListEnd(); } @@ -6414,10 +6664,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 _iter498; - for (_iter498 = (*(this->part_vals)).begin(); _iter498 != (*(this->part_vals)).end(); ++_iter498) + std::vector<std::string> ::const_iterator _iter531; + for (_iter531 = (*(this->part_vals)).begin(); _iter531 != (*(this->part_vals)).end(); ++_iter531) { - xfer += oprot->writeString((*_iter498)); + xfer += oprot->writeString((*_iter531)); } xfer += oprot->writeListEnd(); } @@ -6846,14 +7096,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size499; - ::apache::thrift::protocol::TType _etype502; - xfer += iprot->readListBegin(_etype502, _size499); - this->part_vals.resize(_size499); - uint32_t _i503; - for (_i503 = 0; _i503 < _size499; ++_i503) + 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) { - xfer += iprot->readString(this->part_vals[_i503]); + xfer += iprot->readString(this->part_vals[_i536]); } xfer += iprot->readListEnd(); } @@ -6897,10 +7147,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 _iter504; - for (_iter504 = this->part_vals.begin(); _iter504 != this->part_vals.end(); ++_iter504) + std::vector<std::string> ::const_iterator _iter537; + for (_iter537 = this->part_vals.begin(); _iter537 != this->part_vals.end(); ++_iter537) { - xfer += oprot->writeString((*_iter504)); + xfer += oprot->writeString((*_iter537)); } xfer += oprot->writeListEnd(); } @@ -6930,10 +7180,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 _iter505; - for (_iter505 = (*(this->part_vals)).begin(); _iter505 != (*(this->part_vals)).end(); ++_iter505) + std::vector<std::string> ::const_iterator _iter538; + for (_iter538 = (*(this->part_vals)).begin(); _iter538 != (*(this->part_vals)).end(); ++_iter538) { - xfer += oprot->writeString((*_iter505)); + xfer += oprot->writeString((*_iter538)); } xfer += oprot->writeListEnd(); } @@ -7668,14 +7918,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size506; - ::apache::thrift::protocol::TType _etype509; - xfer += iprot->readListBegin(_etype509, _size506); - this->part_vals.resize(_size506); - uint32_t _i510; - for (_i510 = 0; _i510 < _size506; ++_i510) + 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) { - xfer += iprot->readString(this->part_vals[_i510]); + xfer += iprot->readString(this->part_vals[_i543]); } xfer += iprot->readListEnd(); } @@ -7719,10 +7969,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 _iter511; - for (_iter511 = this->part_vals.begin(); _iter511 != this->part_vals.end(); ++_iter511) + std::vector<std::string> ::const_iterator _iter544; + for (_iter544 = this->part_vals.begin(); _iter544 != this->part_vals.end(); ++_iter544) { - xfer += oprot->writeString((*_iter511)); + xfer += oprot->writeString((*_iter544)); } xfer += oprot->writeListEnd(); } @@ -7752,10 +8002,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 _iter512; - for (_iter512 = (*(this->part_vals)).begin(); _iter512 != (*(this->part_vals)).end(); ++_iter512) + std::vector<std::string> ::const_iterator _iter545; + for (_iter545 = (*(this->part_vals)).begin(); _iter545 != (*(this->part_vals)).end(); ++_iter545) { - xfer += oprot->writeString((*_iter512)); + xfer += oprot->writeString((*_iter545)); } xfer += oprot->writeListEnd(); } @@ -7946,14 +8196,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size513; - ::apache::thrift::protocol::TType _etype516; - xfer += iprot->readListBegin(_etype516, _size513); - this->part_vals.resize(_size513); - uint32_t _i517; - for (_i517 = 0; _i517 < _size513; ++_i517) + 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) { - xfer += iprot->readString(this->part_vals[_i517]); + xfer += iprot->readString(this->part_vals[_i550]); } xfer += iprot->readListEnd(); } @@ -8005,10 +8255,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 _iter518; - for (_iter518 = this->part_vals.begin(); _iter518 != this->part_vals.end(); ++_iter518) + std::vector<std::string> ::const_iterator _iter551; + for (_iter551 = this->part_vals.begin(); _iter551 != this->part_vals.end(); ++_iter551) { - xfer += oprot->writeString((*_iter518)); + xfer += oprot->writeString((*_iter551)); } xfer += oprot->writeListEnd(); } @@ -8042,10 +8292,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 _iter519; - for (_iter519 = (*(this->part_vals)).begin(); _iter519 != (*(this->part_vals)).end(); ++_iter519) + std::vector<std::string> ::const_iterator _iter552; + for (_iter552 = (*(this->part_vals)).begin(); _iter552 != (*(this->part_vals)).end(); ++_iter552) { - xfer += oprot->writeString((*_iter519)); + xfer += oprot->writeString((*_iter552)); } xfer += oprot->writeListEnd(); } @@ -8958,14 +9208,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 _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) { - xfer += iprot->readString(this->part_vals[_i524]); + xfer += iprot->readString(this->part_vals[_i557]); } xfer += iprot->readListEnd(); } @@ -9001,10 +9251,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 _iter525; - for (_iter525 = this->part_vals.begin(); _iter525 != this->part_vals.end(); ++_iter525) + std::vector<std::string> ::const_iterator _iter558; + for (_iter558 = this->part_vals.begin(); _iter558 != this->part_vals.end(); ++_iter558) { - xfer += oprot->writeString((*_iter525)); + xfer += oprot->writeString((*_iter558)); } xfer += oprot->writeListEnd(); } @@ -9030,10 +9280,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 _iter526; - for (_iter526 = (*(this->part_vals)).begin(); _iter526 != (*(this->part_vals)).end(); ++_iter526) + std::vector<std::string> ::const_iterator _iter559; + for (_iter559 = (*(this->part_vals)).begin(); _iter559 != (*(this->part_vals)).end(); ++_iter559) { - xfer += oprot->writeString((*_iter526)); + xfer += oprot->writeString((*_iter559)); } xfer += oprot->writeListEnd(); } @@ -9204,17 +9454,17 @@ uint32_t ThriftHiveMetastore_exchange_pa if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size527; - ::apache::thrift::protocol::TType _ktype528; - ::apache::thrift::protocol::TType _vtype529; - xfer += iprot->readMapBegin(_ktype528, _vtype529, _size527); - uint32_t _i531; - for (_i531 = 0; _i531 < _size527; ++_i531) + 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) { - std::string _key532; - xfer += iprot->readString(_key532); - std::string& _val533 = this->partitionSpecs[_key532]; - xfer += iprot->readString(_val533); + std::string _key565; + xfer += iprot->readString(_key565); + std::string& _val566 = this->partitionSpecs[_key565]; + xfer += iprot->readString(_val566); } xfer += iprot->readMapEnd(); } @@ -9274,11 +9524,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 _iter534; - for (_iter534 = this->partitionSpecs.begin(); _iter534 != this->partitionSpecs.end(); ++_iter534) + std::map<std::string, std::string> ::const_iterator _iter567; + for (_iter567 = this->partitionSpecs.begin(); _iter567 != this->partitionSpecs.end(); ++_iter567) { - xfer += oprot->writeString(_iter534->first); - xfer += oprot->writeString(_iter534->second); + xfer += oprot->writeString(_iter567->first); + xfer += oprot->writeString(_iter567->second); } xfer += oprot->writeMapEnd(); } @@ -9312,11 +9562,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 _iter535; - for (_iter535 = (*(this->partitionSpecs)).begin(); _iter535 != (*(this->partitionSpecs)).end(); ++_iter535) + std::map<std::string, std::string> ::const_iterator _iter568; + for (_iter568 = (*(this->partitionSpecs)).begin(); _iter568 != (*(this->partitionSpecs)).end(); ++_iter568) { - xfer += oprot->writeString(_iter535->first); - xfer += oprot->writeString(_iter535->second); + xfer += oprot->writeString(_iter568->first); + xfer += oprot->writeString(_iter568->second); } xfer += oprot->writeMapEnd(); } @@ -9559,14 +9809,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size536; - ::apache::thrift::protocol::TType _etype539; - xfer += iprot->readListBegin(_etype539, _size536); - this->part_vals.resize(_size536); - uint32_t _i540; - for (_i540 = 0; _i540 < _size536; ++_i540) + 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) { - xfer += iprot->readString(this->part_vals[_i540]); + xfer += iprot->readString(this->part_vals[_i573]); } xfer += iprot->readListEnd(); } @@ -9587,14 +9837,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size541; - ::apache::thrift::protocol::TType _etype544; - xfer += iprot->readListBegin(_etype544, _size541); - this->group_names.resize(_size541); - uint32_t _i545; - for (_i545 = 0; _i545 < _size541; ++_i545) + 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) { - xfer += iprot->readString(this->group_names[_i545]); + xfer += iprot->readString(this->group_names[_i578]); } xfer += iprot->readListEnd(); } @@ -9630,10 +9880,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 _iter546; - for (_iter546 = this->part_vals.begin(); _iter546 != this->part_vals.end(); ++_iter546) + std::vector<std::string> ::const_iterator _iter579; + for (_iter579 = this->part_vals.begin(); _iter579 != this->part_vals.end(); ++_iter579) { - xfer += oprot->writeString((*_iter546)); + xfer += oprot->writeString((*_iter579)); } xfer += oprot->writeListEnd(); } @@ -9646,10 +9896,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 _iter547; - for (_iter547 = this->group_names.begin(); _iter547 != this->group_names.end(); ++_iter547) + std::vector<std::string> ::const_iterator _iter580; + for (_iter580 = this->group_names.begin(); _iter580 != this->group_names.end(); ++_iter580) { - xfer += oprot->writeString((*_iter547)); + xfer += oprot->writeString((*_iter580)); } xfer += oprot->writeListEnd(); } @@ -9675,10 +9925,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 _iter548; - for (_iter548 = (*(this->part_vals)).begin(); _iter548 != (*(this->part_vals)).end(); ++_iter548) + std::vector<std::string> ::const_iterator _iter581; + for (_iter581 = (*(this->part_vals)).begin(); _iter581 != (*(this->part_vals)).end(); ++_iter581) { - xfer += oprot->writeString((*_iter548)); + xfer += oprot->writeString((*_iter581)); } xfer += oprot->writeListEnd(); } @@ -9691,10 +9941,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 _iter549; - for (_iter549 = (*(this->group_names)).begin(); _iter549 != (*(this->group_names)).end(); ++_iter549) + std::vector<std::string> ::const_iterator _iter582; + for (_iter582 = (*(this->group_names)).begin(); _iter582 != (*(this->group_names)).end(); ++_iter582) { - xfer += oprot->writeString((*_iter549)); + xfer += oprot->writeString((*_iter582)); } xfer += oprot->writeListEnd(); } @@ -10197,14 +10447,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size550; - ::apache::thrift::protocol::TType _etype553; - xfer += iprot->readListBegin(_etype553, _size550); - this->success.resize(_size550); - uint32_t _i554; - for (_i554 = 0; _i554 < _size550; ++_i554) + 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) { - xfer += this->success[_i554].read(iprot); + xfer += this->success[_i587].read(iprot); } xfer += iprot->readListEnd(); } @@ -10251,10 +10501,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 _iter555; - for (_iter555 = this->success.begin(); _iter555 != this->success.end(); ++_iter555) + std::vector<Partition> ::const_iterator _iter588; + for (_iter588 = this->success.begin(); _iter588 != this->success.end(); ++_iter588) { - xfer += (*_iter555).write(oprot); + xfer += (*_iter588).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10297,14 +10547,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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))[_i560].read(iprot); + xfer += (*(this->success))[_i593].read(iprot); } xfer += iprot->readListEnd(); } @@ -10397,14 +10647,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size561; - ::apache::thrift::protocol::TType _etype564; - xfer += iprot->readListBegin(_etype564, _size561); - this->group_names.resize(_size561); - uint32_t _i565; - for (_i565 = 0; _i565 < _size561; ++_i565) + 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) { - xfer += iprot->readString(this->group_names[_i565]); + xfer += iprot->readString(this->group_names[_i598]); } xfer += iprot->readListEnd(); } @@ -10448,10 +10698,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 _iter566; - for (_iter566 = this->group_names.begin(); _iter566 != this->group_names.end(); ++_iter566) + std::vector<std::string> ::const_iterator _iter599; + for (_iter599 = this->group_names.begin(); _iter599 != this->group_names.end(); ++_iter599) { - xfer += oprot->writeString((*_iter566)); + xfer += oprot->writeString((*_iter599)); } xfer += oprot->writeListEnd(); } @@ -10485,10 +10735,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 _iter567; - for (_iter567 = (*(this->group_names)).begin(); _iter567 != (*(this->group_names)).end(); ++_iter567) + std::vector<std::string> ::const_iterator _iter600; + for (_iter600 = (*(this->group_names)).begin(); _iter600 != (*(this->group_names)).end(); ++_iter600) { - xfer += oprot->writeString((*_iter567)); + xfer += oprot->writeString((*_iter600)); } xfer += oprot->writeListEnd(); } @@ -10523,14 +10773,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size568; - ::apache::thrift::protocol::TType _etype571; - xfer += iprot->readListBegin(_etype571, _size568); - this->success.resize(_size568); - uint32_t _i572; - for (_i572 = 0; _i572 < _size568; ++_i572) + 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) { - xfer += this->success[_i572].read(iprot); + xfer += this->success[_i605].read(iprot); } xfer += iprot->readListEnd(); } @@ -10577,10 +10827,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 _iter573; - for (_iter573 = this->success.begin(); _iter573 != this->success.end(); ++_iter573) + std::vector<Partition> ::const_iterator _iter606; + for (_iter606 = this->success.begin(); _iter606 != this->success.end(); ++_iter606) { - xfer += (*_iter573).write(oprot); + xfer += (*_iter606).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10623,14 +10873,280 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - (*(this->success)).resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + 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))[_i611].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I32, 3); + xfer += oprot->writeI32((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + 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) { - xfer += (*(this->success))[_i578].read(iprot); + xfer += this->success[_i616].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_pspec_result"); + + if (this->__isset.success) { + 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) + { + xfer += (*_iter617).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + 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) + { + xfer += (*(this->success))[_i622].read(iprot); } xfer += iprot->readListEnd(); } @@ -10789,14 +11305,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size579; - ::apache::thrift::protocol::TType _etype582; - xfer += iprot->readListBegin(_etype582, _size579); - this->success.resize(_size579); - uint32_t _i583; - for (_i583 = 0; _i583 < _size579; ++_i583) + 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) { - xfer += iprot->readString(this->success[_i583]); + xfer += iprot->readString(this->success[_i627]); } xfer += iprot->readListEnd(); } @@ -10835,10 +11351,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 _iter584; - for (_iter584 = this->success.begin(); _iter584 != this->success.end(); ++_iter584) + std::vector<std::string> ::const_iterator _iter628; + for (_iter628 = this->success.begin(); _iter628 != this->success.end(); ++_iter628) { - xfer += oprot->writeString((*_iter584)); + xfer += oprot->writeString((*_iter628)); } xfer += oprot->writeListEnd(); } @@ -10877,14 +11393,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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))[_i589]); + xfer += iprot->readString((*(this->success))[_i633]); } xfer += iprot->readListEnd(); } @@ -10953,14 +11469,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size590; - ::apache::thrift::protocol::TType _etype593; - xfer += iprot->readListBegin(_etype593, _size590); - this->part_vals.resize(_size590); - uint32_t _i594; - for (_i594 = 0; _i594 < _size590; ++_i594) + 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) { - xfer += iprot->readString(this->part_vals[_i594]); + xfer += iprot->readString(this->part_vals[_i638]); } xfer += iprot->readListEnd(); } @@ -11001,30 +11517,384 @@ uint32_t ThriftHiveMetastore_get_partiti xfer += oprot->writeString(this->tbl_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + 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) + { + xfer += oprot->writeString((*_iter639)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + 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) + { + xfer += oprot->writeString((*_iter640)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16((*(this->max_parts))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + 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) + { + xfer += this->success[_i645].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_result"); + + if (this->__isset.success) { + 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) + { + xfer += (*_iter646).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + 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) + { + xfer += (*(this->success))[_i651].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + 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) + { + xfer += iprot->readString(this->part_vals[_i656]); + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I16) { + xfer += iprot->readI16(this->max_parts); + this->__isset.max_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->user_name); + this->__isset.user_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + 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) + { + xfer += iprot->readString(this->group_names[_i661]); + } + xfer += iprot->readListEnd(); + } + this->__isset.group_names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_with_auth_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + 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) + { + xfer += oprot->writeString((*_iter662)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("max_parts", ::apache::thrift::protocol::T_I16, 4); + xfer += oprot->writeI16(this->max_parts); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("user_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->user_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter595; - for (_iter595 = this->part_vals.begin(); _iter595 != this->part_vals.end(); ++_iter595) + 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) {
[... 2266 lines stripped ...]
