Modified: hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp URL: http://svn.apache.org/viewvc/hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1619936&r1=1619935&r2=1619936&view=diff ============================================================================== --- hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original) +++ hive/branches/cbo/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Fri Aug 22 21:36:47 2014 @@ -8,6 +8,366 @@ namespace Apache { namespace Hadoop { namespace Hive { +uint32_t ThriftHiveMetastore_getMetaConf_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->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_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_STRING) { + xfer += iprot->readString(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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_getMetaConf_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0); + xfer += oprot->writeString(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(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_getMetaConf_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_STRING) { + xfer += iprot->readString((*(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; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_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->key); + this->__isset.key = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->value); + this->__isset.value = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_args"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->key); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->value); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_pargs"); + + xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->key))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->value))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_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 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_setMetaConf_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_setMetaConf_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 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + uint32_t ThriftHiveMetastore_create_database_args::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; @@ -736,14 +1096,14 @@ uint32_t ThriftHiveMetastore_get_databas if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i373]); + xfer += iprot->readString(this->success[_i379]); } xfer += iprot->readListEnd(); } @@ -782,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 _iter374; - for (_iter374 = this->success.begin(); _iter374 != this->success.end(); ++_iter374) + std::vector<std::string> ::const_iterator _iter380; + for (_iter380 = this->success.begin(); _iter380 != this->success.end(); ++_iter380) { - xfer += oprot->writeString((*_iter374)); + xfer += oprot->writeString((*_iter380)); } xfer += oprot->writeListEnd(); } @@ -824,14 +1184,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 _size381; + ::apache::thrift::protocol::TType _etype384; + xfer += iprot->readListBegin(_etype384, _size381); + (*(this->success)).resize(_size381); + uint32_t _i385; + for (_i385 = 0; _i385 < _size381; ++_i385) { - xfer += iprot->readString((*(this->success))[_i379]); + xfer += iprot->readString((*(this->success))[_i385]); } xfer += iprot->readListEnd(); } @@ -929,14 +1289,14 @@ uint32_t ThriftHiveMetastore_get_all_dat if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i384]); + xfer += iprot->readString(this->success[_i390]); } xfer += iprot->readListEnd(); } @@ -975,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 _iter385; - for (_iter385 = this->success.begin(); _iter385 != this->success.end(); ++_iter385) + std::vector<std::string> ::const_iterator _iter391; + for (_iter391 = this->success.begin(); _iter391 != this->success.end(); ++_iter391) { - xfer += oprot->writeString((*_iter385)); + xfer += oprot->writeString((*_iter391)); } xfer += oprot->writeListEnd(); } @@ -1017,14 +1377,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 _size392; + ::apache::thrift::protocol::TType _etype395; + xfer += iprot->readListBegin(_etype395, _size392); + (*(this->success)).resize(_size392); + uint32_t _i396; + for (_i396 = 0; _i396 < _size392; ++_i396) { - xfer += iprot->readString((*(this->success))[_i390]); + xfer += iprot->readString((*(this->success))[_i396]); } xfer += iprot->readListEnd(); } @@ -1967,17 +2327,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size391; - ::apache::thrift::protocol::TType _ktype392; - ::apache::thrift::protocol::TType _vtype393; - xfer += iprot->readMapBegin(_ktype392, _vtype393, _size391); - uint32_t _i395; - for (_i395 = 0; _i395 < _size391; ++_i395) + 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) { - std::string _key396; - xfer += iprot->readString(_key396); - Type& _val397 = this->success[_key396]; - xfer += _val397.read(iprot); + std::string _key402; + xfer += iprot->readString(_key402); + Type& _val403 = this->success[_key402]; + xfer += _val403.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2016,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 _iter398; - for (_iter398 = this->success.begin(); _iter398 != this->success.end(); ++_iter398) + std::map<std::string, Type> ::const_iterator _iter404; + for (_iter404 = this->success.begin(); _iter404 != this->success.end(); ++_iter404) { - xfer += oprot->writeString(_iter398->first); - xfer += _iter398->second.write(oprot); + xfer += oprot->writeString(_iter404->first); + xfer += _iter404->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2059,17 +2419,17 @@ uint32_t ThriftHiveMetastore_get_type_al if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size399; - ::apache::thrift::protocol::TType _ktype400; - ::apache::thrift::protocol::TType _vtype401; - xfer += iprot->readMapBegin(_ktype400, _vtype401, _size399); - uint32_t _i403; - for (_i403 = 0; _i403 < _size399; ++_i403) + 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) { - std::string _key404; - xfer += iprot->readString(_key404); - Type& _val405 = (*(this->success))[_key404]; - xfer += _val405.read(iprot); + std::string _key410; + xfer += iprot->readString(_key410); + Type& _val411 = (*(this->success))[_key410]; + xfer += _val411.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2204,14 +2564,14 @@ uint32_t ThriftHiveMetastore_get_fields_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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 += this->success[_i410].read(iprot); + xfer += this->success[_i416].read(iprot); } xfer += iprot->readListEnd(); } @@ -2266,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 _iter411; - for (_iter411 = this->success.begin(); _iter411 != this->success.end(); ++_iter411) + std::vector<FieldSchema> ::const_iterator _iter417; + for (_iter417 = this->success.begin(); _iter417 != this->success.end(); ++_iter417) { - xfer += (*_iter411).write(oprot); + xfer += (*_iter417).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2316,14 +2676,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 _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 += (*(this->success))[_i416].read(iprot); + xfer += (*(this->success))[_i422].read(iprot); } xfer += iprot->readListEnd(); } @@ -2474,14 +2834,14 @@ uint32_t ThriftHiveMetastore_get_schema_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i421].read(iprot); + xfer += this->success[_i427].read(iprot); } xfer += iprot->readListEnd(); } @@ -2536,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 _iter422; - for (_iter422 = this->success.begin(); _iter422 != this->success.end(); ++_iter422) + std::vector<FieldSchema> ::const_iterator _iter428; + for (_iter428 = this->success.begin(); _iter428 != this->success.end(); ++_iter428) { - xfer += (*_iter422).write(oprot); + xfer += (*_iter428).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2586,14 +2946,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 _size429; + ::apache::thrift::protocol::TType _etype432; + xfer += iprot->readListBegin(_etype432, _size429); + (*(this->success)).resize(_size429); + uint32_t _i433; + for (_i433 = 0; _i433 < _size429; ++_i433) { - xfer += (*(this->success))[_i427].read(iprot); + xfer += (*(this->success))[_i433].read(iprot); } xfer += iprot->readListEnd(); } @@ -3648,14 +4008,14 @@ uint32_t ThriftHiveMetastore_get_tables_ if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i432]); + xfer += iprot->readString(this->success[_i438]); } xfer += iprot->readListEnd(); } @@ -3694,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 _iter433; - for (_iter433 = this->success.begin(); _iter433 != this->success.end(); ++_iter433) + std::vector<std::string> ::const_iterator _iter439; + for (_iter439 = this->success.begin(); _iter439 != this->success.end(); ++_iter439) { - xfer += oprot->writeString((*_iter433)); + xfer += oprot->writeString((*_iter439)); } xfer += oprot->writeListEnd(); } @@ -3736,14 +4096,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 _size440; + ::apache::thrift::protocol::TType _etype443; + xfer += iprot->readListBegin(_etype443, _size440); + (*(this->success)).resize(_size440); + uint32_t _i444; + for (_i444 = 0; _i444 < _size440; ++_i444) { - xfer += iprot->readString((*(this->success))[_i438]); + xfer += iprot->readString((*(this->success))[_i444]); } xfer += iprot->readListEnd(); } @@ -3862,14 +4222,14 @@ uint32_t ThriftHiveMetastore_get_all_tab if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i443]); + xfer += iprot->readString(this->success[_i449]); } xfer += iprot->readListEnd(); } @@ -3908,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 _iter444; - for (_iter444 = this->success.begin(); _iter444 != this->success.end(); ++_iter444) + std::vector<std::string> ::const_iterator _iter450; + for (_iter450 = this->success.begin(); _iter450 != this->success.end(); ++_iter450) { - xfer += oprot->writeString((*_iter444)); + xfer += oprot->writeString((*_iter450)); } xfer += oprot->writeListEnd(); } @@ -3950,14 +4310,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 _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 += iprot->readString((*(this->success))[_i449]); + xfer += iprot->readString((*(this->success))[_i455]); } xfer += iprot->readListEnd(); } @@ -4236,14 +4596,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size450; - ::apache::thrift::protocol::TType _etype453; - xfer += iprot->readListBegin(_etype453, _size450); - this->tbl_names.resize(_size450); - uint32_t _i454; - for (_i454 = 0; _i454 < _size450; ++_i454) + 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) { - xfer += iprot->readString(this->tbl_names[_i454]); + xfer += iprot->readString(this->tbl_names[_i460]); } xfer += iprot->readListEnd(); } @@ -4275,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 _iter455; - for (_iter455 = this->tbl_names.begin(); _iter455 != this->tbl_names.end(); ++_iter455) + std::vector<std::string> ::const_iterator _iter461; + for (_iter461 = this->tbl_names.begin(); _iter461 != this->tbl_names.end(); ++_iter461) { - xfer += oprot->writeString((*_iter455)); + xfer += oprot->writeString((*_iter461)); } xfer += oprot->writeListEnd(); } @@ -4300,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 _iter456; - for (_iter456 = (*(this->tbl_names)).begin(); _iter456 != (*(this->tbl_names)).end(); ++_iter456) + std::vector<std::string> ::const_iterator _iter462; + for (_iter462 = (*(this->tbl_names)).begin(); _iter462 != (*(this->tbl_names)).end(); ++_iter462) { - xfer += oprot->writeString((*_iter456)); + xfer += oprot->writeString((*_iter462)); } xfer += oprot->writeListEnd(); } @@ -4338,14 +4698,14 @@ uint32_t ThriftHiveMetastore_get_table_o if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i461].read(iprot); + xfer += this->success[_i467].read(iprot); } xfer += iprot->readListEnd(); } @@ -4400,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 _iter462; - for (_iter462 = this->success.begin(); _iter462 != this->success.end(); ++_iter462) + std::vector<Table> ::const_iterator _iter468; + for (_iter468 = this->success.begin(); _iter468 != this->success.end(); ++_iter468) { - xfer += (*_iter462).write(oprot); + xfer += (*_iter468).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4450,14 +4810,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 _size469; + ::apache::thrift::protocol::TType _etype472; + xfer += iprot->readListBegin(_etype472, _size469); + (*(this->success)).resize(_size469); + uint32_t _i473; + for (_i473 = 0; _i473 < _size469; ++_i473) { - xfer += (*(this->success))[_i467].read(iprot); + xfer += (*(this->success))[_i473].read(iprot); } xfer += iprot->readListEnd(); } @@ -4624,14 +4984,14 @@ uint32_t ThriftHiveMetastore_get_table_n if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i472]); + xfer += iprot->readString(this->success[_i478]); } xfer += iprot->readListEnd(); } @@ -4686,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 _iter473; - for (_iter473 = this->success.begin(); _iter473 != this->success.end(); ++_iter473) + std::vector<std::string> ::const_iterator _iter479; + for (_iter479 = this->success.begin(); _iter479 != this->success.end(); ++_iter479) { - xfer += oprot->writeString((*_iter473)); + xfer += oprot->writeString((*_iter479)); } xfer += oprot->writeListEnd(); } @@ -4736,14 +5096,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 _size480; + ::apache::thrift::protocol::TType _etype483; + xfer += iprot->readListBegin(_etype483, _size480); + (*(this->success)).resize(_size480); + uint32_t _i484; + for (_i484 = 0; _i484 < _size480; ++_i484) { - xfer += iprot->readString((*(this->success))[_i478]); + xfer += iprot->readString((*(this->success))[_i484]); } xfer += iprot->readListEnd(); } @@ -5716,14 +6076,14 @@ uint32_t ThriftHiveMetastore_add_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size479; - ::apache::thrift::protocol::TType _etype482; - xfer += iprot->readListBegin(_etype482, _size479); - this->new_parts.resize(_size479); - uint32_t _i483; - for (_i483 = 0; _i483 < _size479; ++_i483) + 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) { - xfer += this->new_parts[_i483].read(iprot); + xfer += this->new_parts[_i489].read(iprot); } xfer += iprot->readListEnd(); } @@ -5751,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 _iter484; - for (_iter484 = this->new_parts.begin(); _iter484 != this->new_parts.end(); ++_iter484) + std::vector<Partition> ::const_iterator _iter490; + for (_iter490 = this->new_parts.begin(); _iter490 != this->new_parts.end(); ++_iter490) { - xfer += (*_iter484).write(oprot); + xfer += (*_iter490).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5772,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 _iter485; - for (_iter485 = (*(this->new_parts)).begin(); _iter485 != (*(this->new_parts)).end(); ++_iter485) + std::vector<Partition> ::const_iterator _iter491; + for (_iter491 = (*(this->new_parts)).begin(); _iter491 != (*(this->new_parts)).end(); ++_iter491) { - xfer += (*_iter485).write(oprot); + xfer += (*_iter491).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +6342,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size486; - ::apache::thrift::protocol::TType _etype489; - xfer += iprot->readListBegin(_etype489, _size486); - this->part_vals.resize(_size486); - uint32_t _i490; - for (_i490 = 0; _i490 < _size486; ++_i490) + uint32_t _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) { - xfer += iprot->readString(this->part_vals[_i490]); + xfer += iprot->readString(this->part_vals[_i496]); } xfer += iprot->readListEnd(); } @@ -6025,10 +6385,10 @@ uint32_t ThriftHiveMetastore_append_part xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter491; - for (_iter491 = this->part_vals.begin(); _iter491 != this->part_vals.end(); ++_iter491) + std::vector<std::string> ::const_iterator _iter497; + for (_iter497 = this->part_vals.begin(); _iter497 != this->part_vals.end(); ++_iter497) { - xfer += oprot->writeString((*_iter491)); + xfer += oprot->writeString((*_iter497)); } xfer += oprot->writeListEnd(); } @@ -6054,10 +6414,10 @@ uint32_t ThriftHiveMetastore_append_part xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter492; - for (_iter492 = (*(this->part_vals)).begin(); _iter492 != (*(this->part_vals)).end(); ++_iter492) + std::vector<std::string> ::const_iterator _iter498; + for (_iter498 = (*(this->part_vals)).begin(); _iter498 != (*(this->part_vals)).end(); ++_iter498) { - xfer += oprot->writeString((*_iter492)); + xfer += oprot->writeString((*_iter498)); } xfer += oprot->writeListEnd(); } @@ -6486,14 +6846,14 @@ uint32_t ThriftHiveMetastore_append_part if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size493; - ::apache::thrift::protocol::TType _etype496; - xfer += iprot->readListBegin(_etype496, _size493); - this->part_vals.resize(_size493); - uint32_t _i497; - for (_i497 = 0; _i497 < _size493; ++_i497) + uint32_t _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) { - xfer += iprot->readString(this->part_vals[_i497]); + xfer += iprot->readString(this->part_vals[_i503]); } xfer += iprot->readListEnd(); } @@ -6537,10 +6897,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 _iter504; + for (_iter504 = this->part_vals.begin(); _iter504 != this->part_vals.end(); ++_iter504) { - xfer += oprot->writeString((*_iter498)); + xfer += oprot->writeString((*_iter504)); } xfer += oprot->writeListEnd(); } @@ -6570,10 +6930,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 _iter499; - for (_iter499 = (*(this->part_vals)).begin(); _iter499 != (*(this->part_vals)).end(); ++_iter499) + std::vector<std::string> ::const_iterator _iter505; + for (_iter505 = (*(this->part_vals)).begin(); _iter505 != (*(this->part_vals)).end(); ++_iter505) { - xfer += oprot->writeString((*_iter499)); + xfer += oprot->writeString((*_iter505)); } xfer += oprot->writeListEnd(); } @@ -7308,14 +7668,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size500; - ::apache::thrift::protocol::TType _etype503; - xfer += iprot->readListBegin(_etype503, _size500); - this->part_vals.resize(_size500); - uint32_t _i504; - for (_i504 = 0; _i504 < _size500; ++_i504) + uint32_t _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) { - xfer += iprot->readString(this->part_vals[_i504]); + xfer += iprot->readString(this->part_vals[_i510]); } xfer += iprot->readListEnd(); } @@ -7359,10 +7719,10 @@ uint32_t ThriftHiveMetastore_drop_partit xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter505; - for (_iter505 = this->part_vals.begin(); _iter505 != this->part_vals.end(); ++_iter505) + std::vector<std::string> ::const_iterator _iter511; + for (_iter511 = this->part_vals.begin(); _iter511 != this->part_vals.end(); ++_iter511) { - xfer += oprot->writeString((*_iter505)); + xfer += oprot->writeString((*_iter511)); } xfer += oprot->writeListEnd(); } @@ -7392,10 +7752,10 @@ uint32_t ThriftHiveMetastore_drop_partit xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter506; - for (_iter506 = (*(this->part_vals)).begin(); _iter506 != (*(this->part_vals)).end(); ++_iter506) + std::vector<std::string> ::const_iterator _iter512; + for (_iter512 = (*(this->part_vals)).begin(); _iter512 != (*(this->part_vals)).end(); ++_iter512) { - xfer += oprot->writeString((*_iter506)); + xfer += oprot->writeString((*_iter512)); } xfer += oprot->writeListEnd(); } @@ -7586,14 +7946,14 @@ uint32_t ThriftHiveMetastore_drop_partit if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size507; - ::apache::thrift::protocol::TType _etype510; - xfer += iprot->readListBegin(_etype510, _size507); - this->part_vals.resize(_size507); - uint32_t _i511; - for (_i511 = 0; _i511 < _size507; ++_i511) + uint32_t _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) { - xfer += iprot->readString(this->part_vals[_i511]); + xfer += iprot->readString(this->part_vals[_i517]); } xfer += iprot->readListEnd(); } @@ -7645,10 +8005,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 _iter518; + for (_iter518 = this->part_vals.begin(); _iter518 != this->part_vals.end(); ++_iter518) { - xfer += oprot->writeString((*_iter512)); + xfer += oprot->writeString((*_iter518)); } xfer += oprot->writeListEnd(); } @@ -7682,10 +8042,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 _iter513; - for (_iter513 = (*(this->part_vals)).begin(); _iter513 != (*(this->part_vals)).end(); ++_iter513) + std::vector<std::string> ::const_iterator _iter519; + for (_iter519 = (*(this->part_vals)).begin(); _iter519 != (*(this->part_vals)).end(); ++_iter519) { - xfer += oprot->writeString((*_iter513)); + xfer += oprot->writeString((*_iter519)); } xfer += oprot->writeListEnd(); } @@ -8598,14 +8958,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size514; - ::apache::thrift::protocol::TType _etype517; - xfer += iprot->readListBegin(_etype517, _size514); - this->part_vals.resize(_size514); - uint32_t _i518; - for (_i518 = 0; _i518 < _size514; ++_i518) + 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) { - xfer += iprot->readString(this->part_vals[_i518]); + xfer += iprot->readString(this->part_vals[_i524]); } xfer += iprot->readListEnd(); } @@ -8641,10 +9001,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 _iter519; - for (_iter519 = this->part_vals.begin(); _iter519 != this->part_vals.end(); ++_iter519) + std::vector<std::string> ::const_iterator _iter525; + for (_iter525 = this->part_vals.begin(); _iter525 != this->part_vals.end(); ++_iter525) { - xfer += oprot->writeString((*_iter519)); + xfer += oprot->writeString((*_iter525)); } xfer += oprot->writeListEnd(); } @@ -8670,10 +9030,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 _iter520; - for (_iter520 = (*(this->part_vals)).begin(); _iter520 != (*(this->part_vals)).end(); ++_iter520) + std::vector<std::string> ::const_iterator _iter526; + for (_iter526 = (*(this->part_vals)).begin(); _iter526 != (*(this->part_vals)).end(); ++_iter526) { - xfer += oprot->writeString((*_iter520)); + xfer += oprot->writeString((*_iter526)); } xfer += oprot->writeListEnd(); } @@ -8844,17 +9204,17 @@ uint32_t ThriftHiveMetastore_exchange_pa if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size521; - ::apache::thrift::protocol::TType _ktype522; - ::apache::thrift::protocol::TType _vtype523; - xfer += iprot->readMapBegin(_ktype522, _vtype523, _size521); - uint32_t _i525; - for (_i525 = 0; _i525 < _size521; ++_i525) + 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) { - std::string _key526; - xfer += iprot->readString(_key526); - std::string& _val527 = this->partitionSpecs[_key526]; - xfer += iprot->readString(_val527); + std::string _key532; + xfer += iprot->readString(_key532); + std::string& _val533 = this->partitionSpecs[_key532]; + xfer += iprot->readString(_val533); } xfer += iprot->readMapEnd(); } @@ -8914,11 +9274,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 _iter528; - for (_iter528 = this->partitionSpecs.begin(); _iter528 != this->partitionSpecs.end(); ++_iter528) + std::map<std::string, std::string> ::const_iterator _iter534; + for (_iter534 = this->partitionSpecs.begin(); _iter534 != this->partitionSpecs.end(); ++_iter534) { - xfer += oprot->writeString(_iter528->first); - xfer += oprot->writeString(_iter528->second); + xfer += oprot->writeString(_iter534->first); + xfer += oprot->writeString(_iter534->second); } xfer += oprot->writeMapEnd(); } @@ -8952,11 +9312,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 _iter529; - for (_iter529 = (*(this->partitionSpecs)).begin(); _iter529 != (*(this->partitionSpecs)).end(); ++_iter529) + std::map<std::string, std::string> ::const_iterator _iter535; + for (_iter535 = (*(this->partitionSpecs)).begin(); _iter535 != (*(this->partitionSpecs)).end(); ++_iter535) { - xfer += oprot->writeString(_iter529->first); - xfer += oprot->writeString(_iter529->second); + xfer += oprot->writeString(_iter535->first); + xfer += oprot->writeString(_iter535->second); } xfer += oprot->writeMapEnd(); } @@ -9199,14 +9559,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size530; - ::apache::thrift::protocol::TType _etype533; - xfer += iprot->readListBegin(_etype533, _size530); - this->part_vals.resize(_size530); - uint32_t _i534; - for (_i534 = 0; _i534 < _size530; ++_i534) + 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) { - xfer += iprot->readString(this->part_vals[_i534]); + xfer += iprot->readString(this->part_vals[_i540]); } xfer += iprot->readListEnd(); } @@ -9227,14 +9587,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size535; - ::apache::thrift::protocol::TType _etype538; - xfer += iprot->readListBegin(_etype538, _size535); - this->group_names.resize(_size535); - uint32_t _i539; - for (_i539 = 0; _i539 < _size535; ++_i539) + 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) { - xfer += iprot->readString(this->group_names[_i539]); + xfer += iprot->readString(this->group_names[_i545]); } xfer += iprot->readListEnd(); } @@ -9270,10 +9630,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 _iter540; - for (_iter540 = this->part_vals.begin(); _iter540 != this->part_vals.end(); ++_iter540) + std::vector<std::string> ::const_iterator _iter546; + for (_iter546 = this->part_vals.begin(); _iter546 != this->part_vals.end(); ++_iter546) { - xfer += oprot->writeString((*_iter540)); + xfer += oprot->writeString((*_iter546)); } xfer += oprot->writeListEnd(); } @@ -9286,10 +9646,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 _iter541; - for (_iter541 = this->group_names.begin(); _iter541 != this->group_names.end(); ++_iter541) + std::vector<std::string> ::const_iterator _iter547; + for (_iter547 = this->group_names.begin(); _iter547 != this->group_names.end(); ++_iter547) { - xfer += oprot->writeString((*_iter541)); + xfer += oprot->writeString((*_iter547)); } xfer += oprot->writeListEnd(); } @@ -9315,10 +9675,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 _iter542; - for (_iter542 = (*(this->part_vals)).begin(); _iter542 != (*(this->part_vals)).end(); ++_iter542) + std::vector<std::string> ::const_iterator _iter548; + for (_iter548 = (*(this->part_vals)).begin(); _iter548 != (*(this->part_vals)).end(); ++_iter548) { - xfer += oprot->writeString((*_iter542)); + xfer += oprot->writeString((*_iter548)); } xfer += oprot->writeListEnd(); } @@ -9331,10 +9691,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 _iter543; - for (_iter543 = (*(this->group_names)).begin(); _iter543 != (*(this->group_names)).end(); ++_iter543) + std::vector<std::string> ::const_iterator _iter549; + for (_iter549 = (*(this->group_names)).begin(); _iter549 != (*(this->group_names)).end(); ++_iter549) { - xfer += oprot->writeString((*_iter543)); + xfer += oprot->writeString((*_iter549)); } xfer += oprot->writeListEnd(); } @@ -9837,14 +10197,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i548].read(iprot); + xfer += this->success[_i554].read(iprot); } xfer += iprot->readListEnd(); } @@ -9891,10 +10251,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 _iter549; - for (_iter549 = this->success.begin(); _iter549 != this->success.end(); ++_iter549) + std::vector<Partition> ::const_iterator _iter555; + for (_iter555 = this->success.begin(); _iter555 != this->success.end(); ++_iter555) { - xfer += (*_iter549).write(oprot); + xfer += (*_iter555).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9937,14 +10297,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 _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))[_i554].read(iprot); + xfer += (*(this->success))[_i560].read(iprot); } xfer += iprot->readListEnd(); } @@ -10037,14 +10397,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size555; - ::apache::thrift::protocol::TType _etype558; - xfer += iprot->readListBegin(_etype558, _size555); - this->group_names.resize(_size555); - uint32_t _i559; - for (_i559 = 0; _i559 < _size555; ++_i559) + 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) { - xfer += iprot->readString(this->group_names[_i559]); + xfer += iprot->readString(this->group_names[_i565]); } xfer += iprot->readListEnd(); } @@ -10088,10 +10448,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 _iter560; - for (_iter560 = this->group_names.begin(); _iter560 != this->group_names.end(); ++_iter560) + std::vector<std::string> ::const_iterator _iter566; + for (_iter566 = this->group_names.begin(); _iter566 != this->group_names.end(); ++_iter566) { - xfer += oprot->writeString((*_iter560)); + xfer += oprot->writeString((*_iter566)); } xfer += oprot->writeListEnd(); } @@ -10125,10 +10485,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 _iter561; - for (_iter561 = (*(this->group_names)).begin(); _iter561 != (*(this->group_names)).end(); ++_iter561) + std::vector<std::string> ::const_iterator _iter567; + for (_iter567 = (*(this->group_names)).begin(); _iter567 != (*(this->group_names)).end(); ++_iter567) { - xfer += oprot->writeString((*_iter561)); + xfer += oprot->writeString((*_iter567)); } xfer += oprot->writeListEnd(); } @@ -10163,14 +10523,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i566].read(iprot); + xfer += this->success[_i572].read(iprot); } xfer += iprot->readListEnd(); } @@ -10217,10 +10577,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 _iter567; - for (_iter567 = this->success.begin(); _iter567 != this->success.end(); ++_iter567) + std::vector<Partition> ::const_iterator _iter573; + for (_iter573 = this->success.begin(); _iter573 != this->success.end(); ++_iter573) { - xfer += (*_iter567).write(oprot); + xfer += (*_iter573).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10263,14 +10623,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 _size574; + ::apache::thrift::protocol::TType _etype577; + xfer += iprot->readListBegin(_etype577, _size574); + (*(this->success)).resize(_size574); + uint32_t _i578; + for (_i578 = 0; _i578 < _size574; ++_i578) { - xfer += (*(this->success))[_i572].read(iprot); + xfer += (*(this->success))[_i578].read(iprot); } xfer += iprot->readListEnd(); } @@ -10429,14 +10789,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += iprot->readString(this->success[_i577]); + xfer += iprot->readString(this->success[_i583]); } xfer += iprot->readListEnd(); } @@ -10475,10 +10835,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 _iter578; - for (_iter578 = this->success.begin(); _iter578 != this->success.end(); ++_iter578) + std::vector<std::string> ::const_iterator _iter584; + for (_iter584 = this->success.begin(); _iter584 != this->success.end(); ++_iter584) { - xfer += oprot->writeString((*_iter578)); + xfer += oprot->writeString((*_iter584)); } xfer += oprot->writeListEnd(); } @@ -10517,14 +10877,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 _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 += iprot->readString((*(this->success))[_i583]); + xfer += iprot->readString((*(this->success))[_i589]); } xfer += iprot->readListEnd(); } @@ -10593,14 +10953,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size584; - ::apache::thrift::protocol::TType _etype587; - xfer += iprot->readListBegin(_etype587, _size584); - this->part_vals.resize(_size584); - uint32_t _i588; - for (_i588 = 0; _i588 < _size584; ++_i588) + 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) { - xfer += iprot->readString(this->part_vals[_i588]); + xfer += iprot->readString(this->part_vals[_i594]); } xfer += iprot->readListEnd(); } @@ -10644,10 +11004,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 _iter589; - for (_iter589 = this->part_vals.begin(); _iter589 != this->part_vals.end(); ++_iter589) + std::vector<std::string> ::const_iterator _iter595; + for (_iter595 = this->part_vals.begin(); _iter595 != this->part_vals.end(); ++_iter595) { - xfer += oprot->writeString((*_iter589)); + xfer += oprot->writeString((*_iter595)); } xfer += oprot->writeListEnd(); } @@ -10677,10 +11037,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 _iter590; - for (_iter590 = (*(this->part_vals)).begin(); _iter590 != (*(this->part_vals)).end(); ++_iter590) + std::vector<std::string> ::const_iterator _iter596; + for (_iter596 = (*(this->part_vals)).begin(); _iter596 != (*(this->part_vals)).end(); ++_iter596) { - xfer += oprot->writeString((*_iter590)); + xfer += oprot->writeString((*_iter596)); } xfer += oprot->writeListEnd(); } @@ -10719,14 +11079,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size597; + ::apache::thrift::protocol::TType _etype600; + xfer += iprot->readListBegin(_etype600, _size597); + this->success.resize(_size597); + uint32_t _i601; + for (_i601 = 0; _i601 < _size597; ++_i601) { - xfer += this->success[_i595].read(iprot); + xfer += this->success[_i601].read(iprot); } xfer += iprot->readListEnd(); } @@ -10773,10 +11133,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 _iter596; - for (_iter596 = this->success.begin(); _iter596 != this->success.end(); ++_iter596) + std::vector<Partition> ::const_iterator _iter602; + for (_iter602 = this->success.begin(); _iter602 != this->success.end(); ++_iter602) { - xfer += (*_iter596).write(oprot); + xfer += (*_iter602).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10819,14 +11179,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size597; - ::apache::thrift::protocol::TType _etype600; - xfer += iprot->readListBegin(_etype600, _size597); - (*(this->success)).resize(_size597); - uint32_t _i601; - for (_i601 = 0; _i601 < _size597; ++_i601) + uint32_t _size603; + ::apache::thrift::protocol::TType _etype606; + xfer += iprot->readListBegin(_etype606, _size603); + (*(this->success)).resize(_size603); + uint32_t _i607; + for (_i607 = 0; _i607 < _size603; ++_i607) { - xfer += (*(this->success))[_i601].read(iprot); + xfer += (*(this->success))[_i607].read(iprot); } xfer += iprot->readListEnd(); } @@ -10903,14 +11263,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size602; - ::apache::thrift::protocol::TType _etype605; - xfer += iprot->readListBegin(_etype605, _size602); - this->part_vals.resize(_size602); - uint32_t _i606; - for (_i606 = 0; _i606 < _size602; ++_i606) + uint32_t _size608; + ::apache::thrift::protocol::TType _etype611; + xfer += iprot->readListBegin(_etype611, _size608); + this->part_vals.resize(_size608); + uint32_t _i612; + for (_i612 = 0; _i612 < _size608; ++_i612) { - xfer += iprot->readString(this->part_vals[_i606]); + xfer += iprot->readString(this->part_vals[_i612]); } xfer += iprot->readListEnd(); } @@ -10939,14 +11299,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size607; - ::apache::thrift::protocol::TType _etype610; - xfer += iprot->readListBegin(_etype610, _size607); - this->group_names.resize(_size607); - uint32_t _i611; - for (_i611 = 0; _i611 < _size607; ++_i611) + uint32_t _size613; + ::apache::thrift::protocol::TType _etype616; + xfer += iprot->readListBegin(_etype616, _size613); + this->group_names.resize(_size613); + uint32_t _i617; + for (_i617 = 0; _i617 < _size613; ++_i617) { - xfer += iprot->readString(this->group_names[_i611]); + xfer += iprot->readString(this->group_names[_i617]); } xfer += iprot->readListEnd(); } @@ -10982,10 +11342,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 _iter612; - for (_iter612 = this->part_vals.begin(); _iter612 != this->part_vals.end(); ++_iter612) + std::vector<std::string> ::const_iterator _iter618; + for (_iter618 = this->part_vals.begin(); _iter618 != this->part_vals.end(); ++_iter618) { - xfer += oprot->writeString((*_iter612)); + xfer += oprot->writeString((*_iter618)); } xfer += oprot->writeListEnd(); } @@ -11002,10 +11362,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 _iter613; - for (_iter613 = this->group_names.begin(); _iter613 != this->group_names.end(); ++_iter613) + std::vector<std::string> ::const_iterator _iter619; + for (_iter619 = this->group_names.begin(); _iter619 != this->group_names.end(); ++_iter619) { - xfer += oprot->writeString((*_iter613)); + xfer += oprot->writeString((*_iter619)); } xfer += oprot->writeListEnd(); } @@ -11031,10 +11391,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 _iter614; - for (_iter614 = (*(this->part_vals)).begin(); _iter614 != (*(this->part_vals)).end(); ++_iter614) + std::vector<std::string> ::const_iterator _iter620; + for (_iter620 = (*(this->part_vals)).begin(); _iter620 != (*(this->part_vals)).end(); ++_iter620) { - xfer += oprot->writeString((*_iter614)); + xfer += oprot->writeString((*_iter620)); } xfer += oprot->writeListEnd(); } @@ -11051,10 +11411,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 _iter615; - for (_iter615 = (*(this->group_names)).begin(); _iter615 != (*(this->group_names)).end(); ++_iter615) + std::vector<std::string> ::const_iterator _iter621; + for (_iter621 = (*(this->group_names)).begin(); _iter621 != (*(this->group_names)).end(); ++_iter621) { - xfer += oprot->writeString((*_iter615)); + xfer += oprot->writeString((*_iter621)); } xfer += oprot->writeListEnd(); } @@ -11089,14 +11449,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size622; + ::apache::thrift::protocol::TType _etype625; + xfer += iprot->readListBegin(_etype625, _size622); + this->success.resize(_size622); + uint32_t _i626; + for (_i626 = 0; _i626 < _size622; ++_i626) { - xfer += this->success[_i620].read(iprot); + xfer += this->success[_i626].read(iprot); } xfer += iprot->readListEnd(); } @@ -11143,10 +11503,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 _iter621; - for (_iter621 = this->success.begin(); _iter621 != this->success.end(); ++_iter621) + std::vector<Partition> ::const_iterator _iter627; + for (_iter627 = this->success.begin(); _iter627 != this->success.end(); ++_iter627) { - xfer += (*_iter621).write(oprot); + xfer += (*_iter627).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11189,14 +11549,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size622; - ::apache::thrift::protocol::TType _etype625; - xfer += iprot->readListBegin(_etype625, _size622); - (*(this->success)).resize(_size622); - uint32_t _i626; - for (_i626 = 0; _i626 < _size622; ++_i626) + 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 += (*(this->success))[_i626].read(iprot); + xfer += (*(this->success))[_i632].read(iprot); } xfer += iprot->readListEnd(); } @@ -11273,14 +11633,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size627; - ::apache::thrift::protocol::TType _etype630; - xfer += iprot->readListBegin(_etype630, _size627); - this->part_vals.resize(_size627); - uint32_t _i631; - for (_i631 = 0; _i631 < _size627; ++_i631) + uint32_t _size633; + ::apache::thrift::protocol::TType _etype636; + xfer += iprot->readListBegin(_etype636, _size633); + this->part_vals.resize(_size633); + uint32_t _i637; + for (_i637 = 0; _i637 < _size633; ++_i637) { - xfer += iprot->readString(this->part_vals[_i631]); + xfer += iprot->readString(this->part_vals[_i637]); } xfer += iprot->readListEnd(); } @@ -11324,10 +11684,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 _iter632; - for (_iter632 = this->part_vals.begin(); _iter632 != this->part_vals.end(); ++_iter632) + std::vector<std::string> ::const_iterator _iter638; + for (_iter638 = this->part_vals.begin(); _iter638 != this->part_vals.end(); ++_iter638) { - xfer += oprot->writeString((*_iter632)); + xfer += oprot->writeString((*_iter638)); } xfer += oprot->writeListEnd(); } @@ -11357,10 +11717,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 _iter633; - for (_iter633 = (*(this->part_vals)).begin(); _iter633 != (*(this->part_vals)).end(); ++_iter633) + std::vector<std::string> ::const_iterator _iter639; + for (_iter639 = (*(this->part_vals)).begin(); _iter639 != (*(this->part_vals)).end(); ++_iter639) { - xfer += oprot->writeString((*_iter633)); + xfer += oprot->writeString((*_iter639)); } xfer += oprot->writeListEnd(); } @@ -11399,14 +11759,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size640; + ::apache::thrift::protocol::TType _etype643; + xfer += iprot->readListBegin(_etype643, _size640); + this->success.resize(_size640); + uint32_t _i644; + for (_i644 = 0; _i644 < _size640; ++_i644) { - xfer += iprot->readString(this->success[_i638]); + xfer += iprot->readString(this->success[_i644]); } xfer += iprot->readListEnd(); } @@ -11453,10 +11813,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 _iter639; - for (_iter639 = this->success.begin(); _iter639 != this->success.end(); ++_iter639) + std::vector<std::string> ::const_iterator _iter645; + for (_iter645 = this->success.begin(); _iter645 != this->success.end(); ++_iter645) { - xfer += oprot->writeString((*_iter639)); + xfer += oprot->writeString((*_iter645)); } xfer += oprot->writeListEnd(); } @@ -11499,14 +11859,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size640; - ::apache::thrift::protocol::TType _etype643; - xfer += iprot->readListBegin(_etype643, _size640); - (*(this->success)).resize(_size640); - uint32_t _i644; - for (_i644 = 0; _i644 < _size640; ++_i644) + uint32_t _size646; + ::apache::thrift::protocol::TType _etype649; + xfer += iprot->readListBegin(_etype649, _size646); + (*(this->success)).resize(_size646); + uint32_t _i650; + for (_i650 = 0; _i650 < _size646; ++_i650) { - xfer += iprot->readString((*(this->success))[_i644]); + xfer += iprot->readString((*(this->success))[_i650]); } xfer += iprot->readListEnd(); } @@ -11681,14 +12041,14 @@ uint32_t ThriftHiveMetastore_get_partiti if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->success.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) { - xfer += this->success[_i649].read(iprot); + xfer += this->success[_i655].read(iprot); } xfer += iprot->readListEnd(); } @@ -11735,10 +12095,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 _iter650; - for (_iter650 = this->success.begin(); _iter650 != this->success.end(); ++_iter650) + std::vector<Partition> ::const_iterator _iter656;
[... 2188 lines stripped ...]
