http://git-wip-us.apache.org/repos/asf/hive/blob/55a24f0a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index a82c363..6a80db7 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -11672,6 +11672,402 @@ uint32_t ThriftHiveMetastore_exchange_partition_presult::read(::apache::thrift:: } +ThriftHiveMetastore_exchange_partitions_args::~ThriftHiveMetastore_exchange_partitions_args() throw() { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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_MAP) { + { + this->partitionSpecs.clear(); + uint32_t _size904; + ::apache::thrift::protocol::TType _ktype905; + ::apache::thrift::protocol::TType _vtype906; + xfer += iprot->readMapBegin(_ktype905, _vtype906, _size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) + { + std::string _key909; + xfer += iprot->readString(_key909); + std::string& _val910 = this->partitionSpecs[_key909]; + xfer += iprot->readString(_val910); + } + xfer += iprot->readMapEnd(); + } + this->__isset.partitionSpecs = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_db); + this->__isset.source_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->source_table_name); + this->__isset.source_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_db); + this->__isset.dest_db = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dest_table_name); + this->__isset.dest_table_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_args"); + + 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 _iter911; + for (_iter911 = this->partitionSpecs.begin(); _iter911 != this->partitionSpecs.end(); ++_iter911) + { + xfer += oprot->writeString(_iter911->first); + xfer += oprot->writeString(_iter911->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->source_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->source_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->dest_db); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->dest_table_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_pargs::~ThriftHiveMetastore_exchange_partitions_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_pargs"); + + 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 _iter912; + for (_iter912 = (*(this->partitionSpecs)).begin(); _iter912 != (*(this->partitionSpecs)).end(); ++_iter912) + { + xfer += oprot->writeString(_iter912->first); + xfer += oprot->writeString(_iter912->second); + } + xfer += oprot->writeMapEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->source_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->source_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString((*(this->dest_db))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString((*(this->dest_table_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_result::~ThriftHiveMetastore_exchange_partitions_result() throw() { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 _size913; + ::apache::thrift::protocol::TType _etype916; + xfer += iprot->readListBegin(_etype916, _size913); + this->success.resize(_size913); + uint32_t _i917; + for (_i917 = 0; _i917 < _size913; ++_i917) + { + xfer += this->success[_i917].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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_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 _iter918; + for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + { + xfer += (*_iter918).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(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_exchange_partitions_presult::~ThriftHiveMetastore_exchange_partitions_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*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 _size919; + ::apache::thrift::protocol::TType _etype922; + xfer += iprot->readListBegin(_etype922, _size919); + (*(this->success)).resize(_size919); + uint32_t _i923; + for (_i923 = 0; _i923 < _size919; ++_i923) + { + xfer += (*(this->success))[_i923].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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_partition_with_auth_args::~ThriftHiveMetastore_get_partition_with_auth_args() throw() { } @@ -11717,14 +12113,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size904; - ::apache::thrift::protocol::TType _etype907; - xfer += iprot->readListBegin(_etype907, _size904); - this->part_vals.resize(_size904); - uint32_t _i908; - for (_i908 = 0; _i908 < _size904; ++_i908) + uint32_t _size924; + ::apache::thrift::protocol::TType _etype927; + xfer += iprot->readListBegin(_etype927, _size924); + this->part_vals.resize(_size924); + uint32_t _i928; + for (_i928 = 0; _i928 < _size924; ++_i928) { - xfer += iprot->readString(this->part_vals[_i908]); + xfer += iprot->readString(this->part_vals[_i928]); } xfer += iprot->readListEnd(); } @@ -11745,14 +12141,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size909; - ::apache::thrift::protocol::TType _etype912; - xfer += iprot->readListBegin(_etype912, _size909); - this->group_names.resize(_size909); - uint32_t _i913; - for (_i913 = 0; _i913 < _size909; ++_i913) + uint32_t _size929; + ::apache::thrift::protocol::TType _etype932; + xfer += iprot->readListBegin(_etype932, _size929); + this->group_names.resize(_size929); + uint32_t _i933; + for (_i933 = 0; _i933 < _size929; ++_i933) { - xfer += iprot->readString(this->group_names[_i913]); + xfer += iprot->readString(this->group_names[_i933]); } xfer += iprot->readListEnd(); } @@ -11789,10 +12185,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif 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 _iter914; - for (_iter914 = this->part_vals.begin(); _iter914 != this->part_vals.end(); ++_iter914) + std::vector<std::string> ::const_iterator _iter934; + for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) { - xfer += oprot->writeString((*_iter914)); + xfer += oprot->writeString((*_iter934)); } xfer += oprot->writeListEnd(); } @@ -11805,10 +12201,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif 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 _iter915; - for (_iter915 = this->group_names.begin(); _iter915 != this->group_names.end(); ++_iter915) + std::vector<std::string> ::const_iterator _iter935; + for (_iter935 = this->group_names.begin(); _iter935 != this->group_names.end(); ++_iter935) { - xfer += oprot->writeString((*_iter915)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -11840,10 +12236,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri 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 _iter916; - for (_iter916 = (*(this->part_vals)).begin(); _iter916 != (*(this->part_vals)).end(); ++_iter916) + std::vector<std::string> ::const_iterator _iter936; + for (_iter936 = (*(this->part_vals)).begin(); _iter936 != (*(this->part_vals)).end(); ++_iter936) { - xfer += oprot->writeString((*_iter916)); + xfer += oprot->writeString((*_iter936)); } xfer += oprot->writeListEnd(); } @@ -11856,10 +12252,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri 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 _iter917; - for (_iter917 = (*(this->group_names)).begin(); _iter917 != (*(this->group_names)).end(); ++_iter917) + std::vector<std::string> ::const_iterator _iter937; + for (_iter937 = (*(this->group_names)).begin(); _iter937 != (*(this->group_names)).end(); ++_iter937) { - xfer += oprot->writeString((*_iter917)); + xfer += oprot->writeString((*_iter937)); } xfer += oprot->writeListEnd(); } @@ -12418,14 +12814,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size918; - ::apache::thrift::protocol::TType _etype921; - xfer += iprot->readListBegin(_etype921, _size918); - this->success.resize(_size918); - uint32_t _i922; - for (_i922 = 0; _i922 < _size918; ++_i922) + uint32_t _size938; + ::apache::thrift::protocol::TType _etype941; + xfer += iprot->readListBegin(_etype941, _size938); + this->success.resize(_size938); + uint32_t _i942; + for (_i942 = 0; _i942 < _size938; ++_i942) { - xfer += this->success[_i922].read(iprot); + xfer += this->success[_i942].read(iprot); } xfer += iprot->readListEnd(); } @@ -12472,10 +12868,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot 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 _iter923; - for (_iter923 = this->success.begin(); _iter923 != this->success.end(); ++_iter923) + std::vector<Partition> ::const_iterator _iter943; + for (_iter943 = this->success.begin(); _iter943 != this->success.end(); ++_iter943) { - xfer += (*_iter923).write(oprot); + xfer += (*_iter943).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12524,14 +12920,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - (*(this->success)).resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + (*(this->success)).resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += (*(this->success))[_i928].read(iprot); + xfer += (*(this->success))[_i948].read(iprot); } xfer += iprot->readListEnd(); } @@ -12630,14 +13026,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size929; - ::apache::thrift::protocol::TType _etype932; - xfer += iprot->readListBegin(_etype932, _size929); - this->group_names.resize(_size929); - uint32_t _i933; - for (_i933 = 0; _i933 < _size929; ++_i933) + uint32_t _size949; + ::apache::thrift::protocol::TType _etype952; + xfer += iprot->readListBegin(_etype952, _size949); + this->group_names.resize(_size949); + uint32_t _i953; + for (_i953 = 0; _i953 < _size949; ++_i953) { - xfer += iprot->readString(this->group_names[_i933]); + xfer += iprot->readString(this->group_names[_i953]); } xfer += iprot->readListEnd(); } @@ -12682,10 +13078,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri 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 _iter934; - for (_iter934 = this->group_names.begin(); _iter934 != this->group_names.end(); ++_iter934) + std::vector<std::string> ::const_iterator _iter954; + for (_iter954 = this->group_names.begin(); _iter954 != this->group_names.end(); ++_iter954) { - xfer += oprot->writeString((*_iter934)); + xfer += oprot->writeString((*_iter954)); } xfer += oprot->writeListEnd(); } @@ -12725,10 +13121,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr 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 _iter935; - for (_iter935 = (*(this->group_names)).begin(); _iter935 != (*(this->group_names)).end(); ++_iter935) + std::vector<std::string> ::const_iterator _iter955; + for (_iter955 = (*(this->group_names)).begin(); _iter955 != (*(this->group_names)).end(); ++_iter955) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter955)); } xfer += oprot->writeListEnd(); } @@ -12769,14 +13165,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size936; - ::apache::thrift::protocol::TType _etype939; - xfer += iprot->readListBegin(_etype939, _size936); - this->success.resize(_size936); - uint32_t _i940; - for (_i940 = 0; _i940 < _size936; ++_i940) + uint32_t _size956; + ::apache::thrift::protocol::TType _etype959; + xfer += iprot->readListBegin(_etype959, _size956); + this->success.resize(_size956); + uint32_t _i960; + for (_i960 = 0; _i960 < _size956; ++_i960) { - xfer += this->success[_i940].read(iprot); + xfer += this->success[_i960].read(iprot); } xfer += iprot->readListEnd(); } @@ -12823,10 +13219,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th 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 _iter941; - for (_iter941 = this->success.begin(); _iter941 != this->success.end(); ++_iter941) + std::vector<Partition> ::const_iterator _iter961; + for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961) { - xfer += (*_iter941).write(oprot); + xfer += (*_iter961).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12875,14 +13271,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - (*(this->success)).resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size962; + ::apache::thrift::protocol::TType _etype965; + xfer += iprot->readListBegin(_etype965, _size962); + (*(this->success)).resize(_size962); + uint32_t _i966; + for (_i966 = 0; _i966 < _size962; ++_i966) { - xfer += (*(this->success))[_i946].read(iprot); + xfer += (*(this->success))[_i966].read(iprot); } xfer += iprot->readListEnd(); } @@ -13060,14 +13456,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size947; - ::apache::thrift::protocol::TType _etype950; - xfer += iprot->readListBegin(_etype950, _size947); - this->success.resize(_size947); - uint32_t _i951; - for (_i951 = 0; _i951 < _size947; ++_i951) + uint32_t _size967; + ::apache::thrift::protocol::TType _etype970; + xfer += iprot->readListBegin(_etype970, _size967); + this->success.resize(_size967); + uint32_t _i971; + for (_i971 = 0; _i971 < _size967; ++_i971) { - xfer += this->success[_i951].read(iprot); + xfer += this->success[_i971].read(iprot); } xfer += iprot->readListEnd(); } @@ -13114,10 +13510,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift 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 _iter952; - for (_iter952 = this->success.begin(); _iter952 != this->success.end(); ++_iter952) + std::vector<PartitionSpec> ::const_iterator _iter972; + for (_iter972 = this->success.begin(); _iter972 != this->success.end(); ++_iter972) { - xfer += (*_iter952).write(oprot); + xfer += (*_iter972).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13166,14 +13562,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - (*(this->success)).resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + (*(this->success)).resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += (*(this->success))[_i957].read(iprot); + xfer += (*(this->success))[_i977].read(iprot); } xfer += iprot->readListEnd(); } @@ -13351,14 +13747,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size958; - ::apache::thrift::protocol::TType _etype961; - xfer += iprot->readListBegin(_etype961, _size958); - this->success.resize(_size958); - uint32_t _i962; - for (_i962 = 0; _i962 < _size958; ++_i962) + uint32_t _size978; + ::apache::thrift::protocol::TType _etype981; + xfer += iprot->readListBegin(_etype981, _size978); + this->success.resize(_size978); + uint32_t _i982; + for (_i982 = 0; _i982 < _size978; ++_i982) { - xfer += iprot->readString(this->success[_i962]); + xfer += iprot->readString(this->success[_i982]); } xfer += iprot->readListEnd(); } @@ -13397,10 +13793,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: 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 _iter963; - for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter983; + for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter983)); } xfer += oprot->writeListEnd(); } @@ -13445,14 +13841,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - (*(this->success)).resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size984; + ::apache::thrift::protocol::TType _etype987; + xfer += iprot->readListBegin(_etype987, _size984); + (*(this->success)).resize(_size984); + uint32_t _i988; + for (_i988 = 0; _i988 < _size984; ++_i988) { - xfer += iprot->readString((*(this->success))[_i968]); + xfer += iprot->readString((*(this->success))[_i988]); } xfer += iprot->readListEnd(); } @@ -13527,14 +13923,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size969; - ::apache::thrift::protocol::TType _etype972; - xfer += iprot->readListBegin(_etype972, _size969); - this->part_vals.resize(_size969); - uint32_t _i973; - for (_i973 = 0; _i973 < _size969; ++_i973) + uint32_t _size989; + ::apache::thrift::protocol::TType _etype992; + xfer += iprot->readListBegin(_etype992, _size989); + this->part_vals.resize(_size989); + uint32_t _i993; + for (_i993 = 0; _i993 < _size989; ++_i993) { - xfer += iprot->readString(this->part_vals[_i973]); + xfer += iprot->readString(this->part_vals[_i993]); } xfer += iprot->readListEnd(); } @@ -13579,10 +13975,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro 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 _iter974; - for (_iter974 = this->part_vals.begin(); _iter974 != this->part_vals.end(); ++_iter974) + std::vector<std::string> ::const_iterator _iter994; + for (_iter994 = this->part_vals.begin(); _iter994 != this->part_vals.end(); ++_iter994) { - xfer += oprot->writeString((*_iter974)); + xfer += oprot->writeString((*_iter994)); } xfer += oprot->writeListEnd(); } @@ -13618,10 +14014,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr 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 _iter975; - for (_iter975 = (*(this->part_vals)).begin(); _iter975 != (*(this->part_vals)).end(); ++_iter975) + std::vector<std::string> ::const_iterator _iter995; + for (_iter995 = (*(this->part_vals)).begin(); _iter995 != (*(this->part_vals)).end(); ++_iter995) { - xfer += oprot->writeString((*_iter975)); + xfer += oprot->writeString((*_iter995)); } xfer += oprot->writeListEnd(); } @@ -13666,14 +14062,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size976; - ::apache::thrift::protocol::TType _etype979; - xfer += iprot->readListBegin(_etype979, _size976); - this->success.resize(_size976); - uint32_t _i980; - for (_i980 = 0; _i980 < _size976; ++_i980) + uint32_t _size996; + ::apache::thrift::protocol::TType _etype999; + xfer += iprot->readListBegin(_etype999, _size996); + this->success.resize(_size996); + uint32_t _i1000; + for (_i1000 = 0; _i1000 < _size996; ++_i1000) { - xfer += this->success[_i980].read(iprot); + xfer += this->success[_i1000].read(iprot); } xfer += iprot->readListEnd(); } @@ -13720,10 +14116,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p 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 _iter981; - for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) + std::vector<Partition> ::const_iterator _iter1001; + for (_iter1001 = this->success.begin(); _iter1001 != this->success.end(); ++_iter1001) { - xfer += (*_iter981).write(oprot); + xfer += (*_iter1001).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13772,14 +14168,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size982; - ::apache::thrift::protocol::TType _etype985; - xfer += iprot->readListBegin(_etype985, _size982); - (*(this->success)).resize(_size982); - uint32_t _i986; - for (_i986 = 0; _i986 < _size982; ++_i986) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + (*(this->success)).resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += (*(this->success))[_i986].read(iprot); + xfer += (*(this->success))[_i1006].read(iprot); } xfer += iprot->readListEnd(); } @@ -13862,14 +14258,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size987; - ::apache::thrift::protocol::TType _etype990; - xfer += iprot->readListBegin(_etype990, _size987); - this->part_vals.resize(_size987); - uint32_t _i991; - for (_i991 = 0; _i991 < _size987; ++_i991) + uint32_t _size1007; + ::apache::thrift::protocol::TType _etype1010; + xfer += iprot->readListBegin(_etype1010, _size1007); + this->part_vals.resize(_size1007); + uint32_t _i1011; + for (_i1011 = 0; _i1011 < _size1007; ++_i1011) { - xfer += iprot->readString(this->part_vals[_i991]); + xfer += iprot->readString(this->part_vals[_i1011]); } xfer += iprot->readListEnd(); } @@ -13898,14 +14294,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size992; - ::apache::thrift::protocol::TType _etype995; - xfer += iprot->readListBegin(_etype995, _size992); - this->group_names.resize(_size992); - uint32_t _i996; - for (_i996 = 0; _i996 < _size992; ++_i996) + uint32_t _size1012; + ::apache::thrift::protocol::TType _etype1015; + xfer += iprot->readListBegin(_etype1015, _size1012); + this->group_names.resize(_size1012); + uint32_t _i1016; + for (_i1016 = 0; _i1016 < _size1012; ++_i1016) { - xfer += iprot->readString(this->group_names[_i996]); + xfer += iprot->readString(this->group_names[_i1016]); } xfer += iprot->readListEnd(); } @@ -13942,10 +14338,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t 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 _iter997; - for (_iter997 = this->part_vals.begin(); _iter997 != this->part_vals.end(); ++_iter997) + std::vector<std::string> ::const_iterator _iter1017; + for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017) { - xfer += oprot->writeString((*_iter997)); + xfer += oprot->writeString((*_iter1017)); } xfer += oprot->writeListEnd(); } @@ -13962,10 +14358,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t 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 _iter998; - for (_iter998 = this->group_names.begin(); _iter998 != this->group_names.end(); ++_iter998) + std::vector<std::string> ::const_iterator _iter1018; + for (_iter1018 = this->group_names.begin(); _iter1018 != this->group_names.end(); ++_iter1018) { - xfer += oprot->writeString((*_iter998)); + xfer += oprot->writeString((*_iter1018)); } xfer += oprot->writeListEnd(); } @@ -13997,10 +14393,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: 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 _iter999; - for (_iter999 = (*(this->part_vals)).begin(); _iter999 != (*(this->part_vals)).end(); ++_iter999) + std::vector<std::string> ::const_iterator _iter1019; + for (_iter1019 = (*(this->part_vals)).begin(); _iter1019 != (*(this->part_vals)).end(); ++_iter1019) { - xfer += oprot->writeString((*_iter999)); + xfer += oprot->writeString((*_iter1019)); } xfer += oprot->writeListEnd(); } @@ -14017,10 +14413,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: 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 _iter1000; - for (_iter1000 = (*(this->group_names)).begin(); _iter1000 != (*(this->group_names)).end(); ++_iter1000) + std::vector<std::string> ::const_iterator _iter1020; + for (_iter1020 = (*(this->group_names)).begin(); _iter1020 != (*(this->group_names)).end(); ++_iter1020) { - xfer += oprot->writeString((*_iter1000)); + xfer += oprot->writeString((*_iter1020)); } xfer += oprot->writeListEnd(); } @@ -14061,14 +14457,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1001; - ::apache::thrift::protocol::TType _etype1004; - xfer += iprot->readListBegin(_etype1004, _size1001); - this->success.resize(_size1001); - uint32_t _i1005; - for (_i1005 = 0; _i1005 < _size1001; ++_i1005) + uint32_t _size1021; + ::apache::thrift::protocol::TType _etype1024; + xfer += iprot->readListBegin(_etype1024, _size1021); + this->success.resize(_size1021); + uint32_t _i1025; + for (_i1025 = 0; _i1025 < _size1021; ++_i1025) { - xfer += this->success[_i1005].read(iprot); + xfer += this->success[_i1025].read(iprot); } xfer += iprot->readListEnd(); } @@ -14115,10 +14511,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: 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 _iter1006; - for (_iter1006 = this->success.begin(); _iter1006 != this->success.end(); ++_iter1006) + std::vector<Partition> ::const_iterator _iter1026; + for (_iter1026 = this->success.begin(); _iter1026 != this->success.end(); ++_iter1026) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1026).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14167,14 +14563,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - (*(this->success)).resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1027; + ::apache::thrift::protocol::TType _etype1030; + xfer += iprot->readListBegin(_etype1030, _size1027); + (*(this->success)).resize(_size1027); + uint32_t _i1031; + for (_i1031 = 0; _i1031 < _size1027; ++_i1031) { - xfer += (*(this->success))[_i1011].read(iprot); + xfer += (*(this->success))[_i1031].read(iprot); } xfer += iprot->readListEnd(); } @@ -14257,14 +14653,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1012; - ::apache::thrift::protocol::TType _etype1015; - xfer += iprot->readListBegin(_etype1015, _size1012); - this->part_vals.resize(_size1012); - uint32_t _i1016; - for (_i1016 = 0; _i1016 < _size1012; ++_i1016) + uint32_t _size1032; + ::apache::thrift::protocol::TType _etype1035; + xfer += iprot->readListBegin(_etype1035, _size1032); + this->part_vals.resize(_size1032); + uint32_t _i1036; + for (_i1036 = 0; _i1036 < _size1032; ++_i1036) { - xfer += iprot->readString(this->part_vals[_i1016]); + xfer += iprot->readString(this->part_vals[_i1036]); } xfer += iprot->readListEnd(); } @@ -14309,10 +14705,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift 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 _iter1017; - for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017) + std::vector<std::string> ::const_iterator _iter1037; + for (_iter1037 = this->part_vals.begin(); _iter1037 != this->part_vals.end(); ++_iter1037) { - xfer += oprot->writeString((*_iter1017)); + xfer += oprot->writeString((*_iter1037)); } xfer += oprot->writeListEnd(); } @@ -14348,10 +14744,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif 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 _iter1018; - for (_iter1018 = (*(this->part_vals)).begin(); _iter1018 != (*(this->part_vals)).end(); ++_iter1018) + std::vector<std::string> ::const_iterator _iter1038; + for (_iter1038 = (*(this->part_vals)).begin(); _iter1038 != (*(this->part_vals)).end(); ++_iter1038) { - xfer += oprot->writeString((*_iter1018)); + xfer += oprot->writeString((*_iter1038)); } xfer += oprot->writeListEnd(); } @@ -14396,14 +14792,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1019; - ::apache::thrift::protocol::TType _etype1022; - xfer += iprot->readListBegin(_etype1022, _size1019); - this->success.resize(_size1019); - uint32_t _i1023; - for (_i1023 = 0; _i1023 < _size1019; ++_i1023) + uint32_t _size1039; + ::apache::thrift::protocol::TType _etype1042; + xfer += iprot->readListBegin(_etype1042, _size1039); + this->success.resize(_size1039); + uint32_t _i1043; + for (_i1043 = 0; _i1043 < _size1039; ++_i1043) { - xfer += iprot->readString(this->success[_i1023]); + xfer += iprot->readString(this->success[_i1043]); } xfer += iprot->readListEnd(); } @@ -14450,10 +14846,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri 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 _iter1024; - for (_iter1024 = this->success.begin(); _iter1024 != this->success.end(); ++_iter1024) + std::vector<std::string> ::const_iterator _iter1044; + for (_iter1044 = this->success.begin(); _iter1044 != this->success.end(); ++_iter1044) { - xfer += oprot->writeString((*_iter1024)); + xfer += oprot->writeString((*_iter1044)); } xfer += oprot->writeListEnd(); } @@ -14502,14 +14898,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1025; - ::apache::thrift::protocol::TType _etype1028; - xfer += iprot->readListBegin(_etype1028, _size1025); - (*(this->success)).resize(_size1025); - uint32_t _i1029; - for (_i1029 = 0; _i1029 < _size1025; ++_i1029) + uint32_t _size1045; + ::apache::thrift::protocol::TType _etype1048; + xfer += iprot->readListBegin(_etype1048, _size1045); + (*(this->success)).resize(_size1045); + uint32_t _i1049; + for (_i1049 = 0; _i1049 < _size1045; ++_i1049) { - xfer += iprot->readString((*(this->success))[_i1029]); + xfer += iprot->readString((*(this->success))[_i1049]); } xfer += iprot->readListEnd(); } @@ -14703,14 +15099,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1030; - ::apache::thrift::protocol::TType _etype1033; - xfer += iprot->readListBegin(_etype1033, _size1030); - this->success.resize(_size1030); - uint32_t _i1034; - for (_i1034 = 0; _i1034 < _size1030; ++_i1034) + uint32_t _size1050; + ::apache::thrift::protocol::TType _etype1053; + xfer += iprot->readListBegin(_etype1053, _size1050); + this->success.resize(_size1050); + uint32_t _i1054; + for (_i1054 = 0; _i1054 < _size1050; ++_i1054) { - xfer += this->success[_i1034].read(iprot); + xfer += this->success[_i1054].read(iprot); } xfer += iprot->readListEnd(); } @@ -14757,10 +15153,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th 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 _iter1035; - for (_iter1035 = this->success.begin(); _iter1035 != this->success.end(); ++_iter1035) + std::vector<Partition> ::const_iterator _iter1055; + for (_iter1055 = this->success.begin(); _iter1055 != this->success.end(); ++_iter1055) { - xfer += (*_iter1035).write(oprot); + xfer += (*_iter1055).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14809,14 +15205,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1036; - ::apache::thrift::protocol::TType _etype1039; - xfer += iprot->readListBegin(_etype1039, _size1036); - (*(this->success)).resize(_size1036); - uint32_t _i1040; - for (_i1040 = 0; _i1040 < _size1036; ++_i1040) + uint32_t _size1056; + ::apache::thrift::protocol::TType _etype1059; + xfer += iprot->readListBegin(_etype1059, _size1056); + (*(this->success)).resize(_size1056); + uint32_t _i1060; + for (_i1060 = 0; _i1060 < _size1056; ++_i1060) { - xfer += (*(this->success))[_i1040].read(iprot); + xfer += (*(this->success))[_i1060].read(iprot); } xfer += iprot->readListEnd(); } @@ -15010,14 +15406,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1041; - ::apache::thrift::protocol::TType _etype1044; - xfer += iprot->readListBegin(_etype1044, _size1041); - this->success.resize(_size1041); - uint32_t _i1045; - for (_i1045 = 0; _i1045 < _size1041; ++_i1045) + uint32_t _size1061; + ::apache::thrift::protocol::TType _etype1064; + xfer += iprot->readListBegin(_etype1064, _size1061); + this->success.resize(_size1061); + uint32_t _i1065; + for (_i1065 = 0; _i1065 < _size1061; ++_i1065) { - xfer += this->success[_i1045].read(iprot); + xfer += this->success[_i1065].read(iprot); } xfer += iprot->readListEnd(); } @@ -15064,10 +15460,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th 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 _iter1046; - for (_iter1046 = this->success.begin(); _iter1046 != this->success.end(); ++_iter1046) + std::vector<PartitionSpec> ::const_iterator _iter1066; + for (_iter1066 = this->success.begin(); _iter1066 != this->success.end(); ++_iter1066) { - xfer += (*_iter1046).write(oprot); + xfer += (*_iter1066).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15116,14 +15512,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1047; - ::apache::thrift::protocol::TType _etype1050; - xfer += iprot->readListBegin(_etype1050, _size1047); - (*(this->success)).resize(_size1047); - uint32_t _i1051; - for (_i1051 = 0; _i1051 < _size1047; ++_i1051) + uint32_t _size1067; + ::apache::thrift::protocol::TType _etype1070; + xfer += iprot->readListBegin(_etype1070, _size1067); + (*(this->success)).resize(_size1067); + uint32_t _i1071; + for (_i1071 = 0; _i1071 < _size1067; ++_i1071) { - xfer += (*(this->success))[_i1051].read(iprot); + xfer += (*(this->success))[_i1071].read(iprot); } xfer += iprot->readListEnd(); } @@ -15433,14 +15829,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1052; - ::apache::thrift::protocol::TType _etype1055; - xfer += iprot->readListBegin(_etype1055, _size1052); - this->names.resize(_size1052); - uint32_t _i1056; - for (_i1056 = 0; _i1056 < _size1052; ++_i1056) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + this->names.resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += iprot->readString(this->names[_i1056]); + xfer += iprot->readString(this->names[_i1076]); } xfer += iprot->readListEnd(); } @@ -15477,10 +15873,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size())); - std::vector<std::string> ::const_iterator _iter1057; - for (_iter1057 = this->names.begin(); _iter1057 != this->names.end(); ++_iter1057) + std::vector<std::string> ::const_iterator _iter1077; + for (_iter1077 = this->names.begin(); _iter1077 != this->names.end(); ++_iter1077) { - xfer += oprot->writeString((*_iter1057)); + xfer += oprot->writeString((*_iter1077)); } xfer += oprot->writeListEnd(); } @@ -15512,10 +15908,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->names)).size())); - std::vector<std::string> ::const_iterator _iter1058; - for (_iter1058 = (*(this->names)).begin(); _iter1058 != (*(this->names)).end(); ++_iter1058) + std::vector<std::string> ::const_iterator _iter1078; + for (_iter1078 = (*(this->names)).begin(); _iter1078 != (*(this->names)).end(); ++_iter1078) { - xfer += oprot->writeString((*_iter1058)); + xfer += oprot->writeString((*_iter1078)); } xfer += oprot->writeListEnd(); } @@ -15556,14 +15952,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1059; - ::apache::thrift::protocol::TType _etype1062; - xfer += iprot->readListBegin(_etype1062, _size1059); - this->success.resize(_size1059); - uint32_t _i1063; - for (_i1063 = 0; _i1063 < _size1059; ++_i1063) + uint32_t _size1079; + ::apache::thrift::protocol::TType _etype1082; + xfer += iprot->readListBegin(_etype1082, _size1079); + this->success.resize(_size1079); + uint32_t _i1083; + for (_i1083 = 0; _i1083 < _size1079; ++_i1083) { - xfer += this->success[_i1063].read(iprot); + xfer += this->success[_i1083].read(iprot); } xfer += iprot->readListEnd(); } @@ -15610,10 +16006,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr 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 _iter1064; - for (_iter1064 = this->success.begin(); _iter1064 != this->success.end(); ++_iter1064) + std::vector<Partition> ::const_iterator _iter1084; + for (_iter1084 = this->success.begin(); _iter1084 != this->success.end(); ++_iter1084) { - xfer += (*_iter1064).write(oprot); + xfer += (*_iter1084).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15662,14 +16058,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1065; - ::apache::thrift::protocol::TType _etype1068; - xfer += iprot->readListBegin(_etype1068, _size1065); - (*(this->success)).resize(_size1065); - uint32_t _i1069; - for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + uint32_t _size1085; + ::apache::thrift::protocol::TType _etype1088; + xfer += iprot->readListBegin(_etype1088, _size1085); + (*(this->success)).resize(_size1085); + uint32_t _i1089; + for (_i1089 = 0; _i1089 < _size1085; ++_i1089) { - xfer += (*(this->success))[_i1069].read(iprot); + xfer += (*(this->success))[_i1089].read(iprot); } xfer += iprot->readListEnd(); } @@ -15991,14 +16387,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1070; - ::apache::thrift::protocol::TType _etype1073; - xfer += iprot->readListBegin(_etype1073, _size1070); - this->new_parts.resize(_size1070); - uint32_t _i1074; - for (_i1074 = 0; _i1074 < _size1070; ++_i1074) + uint32_t _size1090; + ::apache::thrift::protocol::TType _etype1093; + xfer += iprot->readListBegin(_etype1093, _size1090); + this->new_parts.resize(_size1090); + uint32_t _i1094; + for (_i1094 = 0; _i1094 < _size1090; ++_i1094) { - xfer += this->new_parts[_i1074].read(iprot); + xfer += this->new_parts[_i1094].read(iprot); } xfer += iprot->readListEnd(); } @@ -16035,10 +16431,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter1075; - for (_iter1075 = this->new_parts.begin(); _iter1075 != this->new_parts.end(); ++_iter1075) + std::vector<Partition> ::const_iterator _iter1095; + for (_iter1095 = this->new_parts.begin(); _iter1095 != this->new_parts.end(); ++_iter1095) { - xfer += (*_iter1075).write(oprot); + xfer += (*_iter1095).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16070,10 +16466,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter1076; - for (_iter1076 = (*(this->new_parts)).begin(); _iter1076 != (*(this->new_parts)).end(); ++_iter1076) + std::vector<Partition> ::const_iterator _iter1096; + for (_iter1096 = (*(this->new_parts)).begin(); _iter1096 != (*(this->new_parts)).end(); ++_iter1096) { - xfer += (*_iter1076).write(oprot); + xfer += (*_iter1096).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16513,14 +16909,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1077; - ::apache::thrift::protocol::TType _etype1080; - xfer += iprot->readListBegin(_etype1080, _size1077); - this->part_vals.resize(_size1077); - uint32_t _i1081; - for (_i1081 = 0; _i1081 < _size1077; ++_i1081) + uint32_t _size1097; + ::apache::thrift::protocol::TType _etype1100; + xfer += iprot->readListBegin(_etype1100, _size1097); + this->part_vals.resize(_size1097); + uint32_t _i1101; + for (_i1101 = 0; _i1101 < _size1097; ++_i1101) { - xfer += iprot->readString(this->part_vals[_i1081]); + xfer += iprot->readString(this->part_vals[_i1101]); } xfer += iprot->readListEnd(); } @@ -16565,10 +16961,10 @@ uint32_t ThriftHiveMetastore_rename_partition_args::write(::apache::thrift::prot 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 _iter1082; - for (_iter1082 = this->part_vals.begin(); _iter1082 != this->part_vals.end(); ++_iter1082) + std::vector<std::string> ::const_iterator _iter1102; + for (_iter1102 = this->part_vals.begin(); _iter1102 != this->part_vals.end(); ++_iter1102) { - xfer += oprot->writeString((*_iter1082)); + xfer += oprot->writeString((*_iter1102)); } xfer += oprot->writeListEnd(); } @@ -16604,10 +17000,10 @@ uint32_t ThriftHiveMetastore_rename_partition_pargs::write(::apache::thrift::pro 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 _iter1083; - for (_iter1083 = (*(this->part_vals)).begin(); _iter1083 != (*(this->part_vals)).end(); ++_iter1083) + std::vector<std::string> ::const_iterator _iter1103; + for (_iter1103 = (*(this->part_vals)).begin(); _iter1103 != (*(this->part_vals)).end(); ++_iter1103) { - xfer += oprot->writeString((*_iter1083)); + xfer += oprot->writeString((*_iter1103)); } xfer += oprot->writeListEnd(); } @@ -16780,14 +17176,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1084; - ::apache::thrift::protocol::TType _etype1087; - xfer += iprot->readListBegin(_etype1087, _size1084); - this->part_vals.resize(_size1084); - uint32_t _i1088; - for (_i1088 = 0; _i1088 < _size1084; ++_i1088) + uint32_t _size1104; + ::apache::thrift::protocol::TType _etype1107; + xfer += iprot->readListBegin(_etype1107, _size1104); + this->part_vals.resize(_size1104); + uint32_t _i1108; + for (_i1108 = 0; _i1108 < _size1104; ++_i1108) { - xfer += iprot->readString(this->part_vals[_i1088]); + xfer += iprot->readString(this->part_vals[_i1108]); } xfer += iprot->readListEnd(); } @@ -16824,10 +17220,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1089; - for (_iter1089 = this->part_vals.begin(); _iter1089 != this->part_vals.end(); ++_iter1089) + std::vector<std::string> ::const_iterator _iter1109; + for (_iter1109 = this->part_vals.begin(); _iter1109 != this->part_vals.end(); ++_iter1109) { - xfer += oprot->writeString((*_iter1089)); + xfer += oprot->writeString((*_iter1109)); } xfer += oprot->writeListEnd(); } @@ -16855,10 +17251,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1090; - for (_iter1090 = (*(this->part_vals)).begin(); _iter1090 != (*(this->part_vals)).end(); ++_iter1090) + std::vector<std::string> ::const_iterator _iter1110; + for (_iter1110 = (*(this->part_vals)).begin(); _iter1110 != (*(this->part_vals)).end(); ++_iter1110) { - xfer += oprot->writeString((*_iter1090)); + xfer += oprot->writeString((*_iter1110)); } xfer += oprot->writeListEnd(); } @@ -17333,14 +17729,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1091; - ::apache::thrift::protocol::TType _etype1094; - xfer += iprot->readListBegin(_etype1094, _size1091); - this->success.resize(_size1091); - uint32_t _i1095; - for (_i1095 = 0; _i1095 < _size1091; ++_i1095) + uint32_t _size1111; + ::apache::thrift::protocol::TType _etype1114; + xfer += iprot->readListBegin(_etype1114, _size1111); + this->success.resize(_size1111); + uint32_t _i1115; + for (_i1115 = 0; _i1115 < _size1111; ++_i1115) { - xfer += iprot->readString(this->success[_i1095]); + xfer += iprot->readString(this->success[_i1115]); } xfer += iprot->readListEnd(); } @@ -17379,10 +17775,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri 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 _iter1096; - for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) + std::vector<std::string> ::const_iterator _iter1116; + for (_iter1116 = this->success.begin(); _iter1116 != this->success.end(); ++_iter1116) { - xfer += oprot->writeString((*_iter1096)); + xfer += oprot->writeString((*_iter1116)); } xfer += oprot->writeListEnd(); } @@ -17427,14 +17823,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1097; - ::apache::thrift::protocol::TType _etype1100; - xfer += iprot->readListBegin(_etype1100, _size1097); - (*(this->success)).resize(_size1097); - uint32_t _i1101; - for (_i1101 = 0; _i1101 < _size1097; ++_i1101) + uint32_t _size1117; + ::apache::thrift::protocol::TType _etype1120; + xfer += iprot->readListBegin(_etype1120, _size1117); + (*(this->success)).resize(_size1117); + uint32_t _i1121; + for (_i1121 = 0; _i1121 < _size1117; ++_i1121) { - xfer += iprot->readString((*(this->success))[_i1101]); + xfer += iprot->readString((*(this->success))[_i1121]); } xfer += iprot->readListEnd(); } @@ -17572,17 +17968,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1102; - ::apache::thrift::protocol::TType _ktype1103; - ::apache::thrift::protocol::TType _vtype1104; - xfer += iprot->readMapBegin(_ktype1103, _vtype1104, _size1102); - uint32_t _i1106; - for (_i1106 = 0; _i1106 < _size1102; ++_i1106) + uint32_t _size1122; + ::apache::thrift::protocol::TType _ktype1123; + ::apache::thrift::protocol::TType _vtype1124; + xfer += iprot->readMapBegin(_ktype1123, _vtype1124, _size1122); + uint32_t _i1126; + for (_i1126 = 0; _i1126 < _size1122; ++_i1126) { - std::string _key1107; - xfer += iprot->readString(_key1107); - std::string& _val1108 = this->success[_key1107]; - xfer += iprot->readString(_val1108); + std::string _key1127; + xfer += iprot->readString(_key1127); + std::string& _val1128 = this->success[_key1127]; + xfer += iprot->readString(_val1128); } xfer += iprot->readMapEnd(); } @@ -17621,11 +18017,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::map<std::string, std::string> ::const_iterator _iter1109; - for (_iter1109 = this->success.begin(); _iter1109 != this->success.end(); ++_iter1109) + std::map<std::string, std::string> ::const_iterator _iter1129; + for (_iter1129 = this->success.begin(); _iter1129 != this->success.end(); ++_iter1129) { - xfer += oprot->writeString(_iter1109->first); - xfer += oprot->writeString(_iter1109->second); + xfer += oprot->writeString(_iter1129->first); + xfer += oprot->writeString(_iter1129->second); } xfer += oprot->writeMapEnd(); } @@ -17670,17 +18066,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1110; - ::apache::thrift::protocol::TType _ktype1111; - ::apache::thrift::protocol::TType _vtype1112; - xfer += iprot->readMapBegin(_ktype1111, _vtype1112, _size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1130; + ::apache::thrift::protocol::TType _ktype1131; + ::apache::thrift::protocol::TType _vtype1132; + xfer += iprot->readMapBegin(_ktype1131, _vtype1132, _size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - std::string _key1115; - xfer += iprot->readString(_key1115); - std::string& _val1116 = (*(this->success))[_key1115]; - xfer += iprot->readString(_val1116); + std::string _key1135; + xfer += iprot->readString(_key1135); + std::string& _val1136 = (*(this->success))[_key1135]; + xfer += iprot->readString(_val1136); } xfer += iprot->readMapEnd(); } @@ -17755,17 +18151,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1117; - ::apache::thrift::protocol::TType _ktype1118; - ::apache::thrift::protocol::TType _vtype1119; - xfer += iprot->readMapBegin(_ktype1118, _vtype1119, _size1117); - uint32_t _i1121; - for (_i1121 = 0; _i1121 < _size1117; ++_i1121) + uint32_t _size1137; + ::apache::thrift::protocol::TType _ktype1138; + ::apache::thrift::protocol::TType _vtype1139; + xfer += iprot->readMapBegin(_ktype1138, _vtype1139, _size1137); + uint32_t _i1141; + for (_i1141 = 0; _i1141 < _size1137; ++_i1141) { - std::string _key1122; - xfer += iprot->readString(_key1122); - std::string& _val1123 = this->part_vals[_key1122]; - xfer += iprot->readString(_val1123); + std::string _key1142; + xfer += iprot->readString(_key1142); + std::string& _val1143 = this->part_vals[_key1142]; + xfer += iprot->readString(_val1143); } xfer += iprot->readMapEnd(); } @@ -17776,9 +18172,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1124; - xfer += iprot->readI32(ecast1124); - this->eventType = (PartitionEventType::type)ecast1124; + int32_t ecast1144; + xfer += iprot->readI32(ecast1144); + this->eventType = (PartitionEventType::type)ecast1144; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -17812,11 +18208,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::map<std::string, std::string> ::const_iterator _iter1125; - for (_iter1125 = this->part_vals.begin(); _iter1125 != this->part_vals.end(); ++_iter1125) + std::map<std::string, std::string> ::const_iterator _iter1145; + for (_iter1145 = this->part_vals.begin(); _iter1145 != this->part_vals.end(); ++_iter1145) { - xfer += oprot->writeString(_iter1125->first); - xfer += oprot->writeString(_iter1125->second); + xfer += oprot->writeString(_iter1145->first); + xfer += oprot->writeString(_iter1145->second); } xfer += oprot->writeMapEnd(); } @@ -17852,11 +18248,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::map<std::string, std::string> ::const_iterator _iter1126; - for (_iter1126 = (*(this->part_vals)).begin(); _iter1126 != (*(this->part_vals)).end(); ++_iter1126) + std::map<std::string, std::string> ::const_iterator _iter1146; + for (_iter1146 = (*(this->part_vals)).begin(); _iter1146 != (*(this->part_vals)).end(); ++_iter1146) { - xfer += oprot->writeString(_iter1126->first); - xfer += oprot->writeString(_iter1126->second); + xfer += oprot->writeString(_iter1146->first); + xfer += oprot->writeString(_iter1146->second); } xfer += oprot->writeMapEnd(); } @@ -18125,17 +18521,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1127; - ::apache::thrift::protocol::TType _ktype1128; - ::apache::thrift::protocol::TType _vtype1129; - xfer += iprot->readMapBegin(_ktype1128, _vtype1129, _size1127); - uint32_t _i1131; - for (_i1131 = 0; _i1131 < _size1127; ++_i1131) + uint32_t _size1147; + ::apache::thrift::protocol::TType _ktype1148; + ::apache::thrift::protocol::TType _vtype1149; + xfer += iprot->readMapBegin(_ktype1148, _vtype1149, _size1147); + uint32_t _i1151; + for (_i1151 = 0; _i1151 < _size1147; ++_i1151) { - std::string _key1132; - xfer += iprot->readString(_key1132); - std::string& _val1133 = this->part_vals[_key1132]; - xfer += iprot->readString(_val1133); + std::string _key1152; + xfer += iprot->readString(_key1152); + std::string& _val1153 = this->part_vals[_key1152]; + xfer += iprot->readString(_val1153); } xfer += iprot->readMapEnd(); } @@ -18146,9 +18542,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1134; - xfer += iprot->readI32(ecast1134); - this->eventType = (PartitionEventType::type)ecast1134; + int32_t ecast1154; + xfer += iprot->readI32(ecast1154); + this->eventType = (PartitionEventType::type)ecast1154; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -18182,11 +18578,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::map<std::string, std::string> ::const_iterator _iter1135; - for (_iter1135 = this->part_vals.begin(); _iter1135 != this->part_vals.end(); ++_iter1135) + std::map<std::string, std::string> ::const_iterator _iter1155; + for (_iter1155 = this->part_vals.begin(); _iter1155 != this->part_vals.end(); ++_iter1155) { - xfer += oprot->writeString(_iter1135->first); - xfer += oprot->writeString(_iter1135->second); + xfer += oprot->writeString(_iter1155->first); + xfer += oprot->writeString(_iter1155->second); } xfer += oprot->writeMapEnd(); } @@ -18222,11 +18618,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::map<std::string, std::string> ::const_iterator _iter1136; - for (_iter1136 = (*(this->part_vals)).begin(); _iter1136 != (*(this->part_vals)).end(); ++_iter1136) + std::map<std::string, std::string> ::const_iterator _iter1156; + for (_iter1156 = (*(this->part_vals)).begin(); _iter1156 != (*(this->part_vals)).end(); ++_iter1156) { - xfer += oprot->writeString(_iter1136->first); - xfer += oprot->writeString(_iter1136->second); + xfer += oprot->writeString(_iter1156->first); + xfer += oprot->writeString(_iter1156->second); } xfer += oprot->writeMapEnd(); } @@ -19662,14 +20058,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1137; - ::apache::thrift::protocol::TType _etype1140; - xfer += iprot->readListBegin(_etype1140, _size1137); - this->success.resize(_size1137); - uint32_t _i1141; - for (_i1141 = 0; _i1141 < _size1137; ++_i1141) + uint32_t _size1157; + ::apache::thrift::protocol::TType _etype1160; + xfer += iprot->readListBegin(_etype1160, _size1157); + this->success.resize(_size1157); + uint32_t _i1161; + for (_i1161 = 0; _i1161 < _size1157; ++_i1161) { - xfer += this->success[_i1141].read(iprot); + xfer += this->success[_i1161].read(iprot); } xfer += iprot->readListEnd(); } @@ -19716,10 +20112,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco 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<Index> ::const_iterator _iter1142; - for (_iter1142 = this->success.begin(); _iter1142 != this->success.end(); ++_iter1142) + std::vector<Index> ::const_iterator _iter1162; + for (_iter1162 = this->success.begin(); _iter1162 != this->success.end(); ++_iter1162) { - xfer += (*_iter1142).write(oprot); + xfer += (*_iter1162).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19768,14 +20164,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1143; - ::apache::thrift::protocol::TType _etype1146; - xfer += iprot->readListBegin(_etype1146, _size1143); - (*(this->success)).resize(_size1143); - uint32_t _i1147; - for (_i1147 = 0; _i1147 < _size1143; ++_i1147) + uint32_t _size1163; + ::apache::thrift::protocol::TType _etype1166; + xfer += iprot->readListBegin(_etype1166, _size1163); + (*(this->success)).resize(_size1163); + uint32_t _i1167; + for (_i1167 = 0; _i1167 < _size1163; ++_i1167) { - xfer += (*(this->success))[_i1147].read(iprot); + xfer += (*(this->success))[_i1167].read(iprot); } xfer += iprot->readListEnd(); } @@ -19953,14 +20349,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1148; - ::apache::thrift::protocol::TType _etype1151; - xfer += iprot->readListBegin(_etype1151, _size1148); - this->success.resize(_size1148); - uint32_t _i1152; - for (_i1152 = 0; _i1152 < _size1148; ++_i1152) + uint32_t _size1168; + ::apache::thrift::protocol::TType _etype1171; + xfer += iprot->readListBegin(_etype1171, _size1168); + this->success.resize(_size1168); + uint32_t _i1172; + for (_i1172 = 0; _i1172 < _size1168; ++_i1172) { - xfer += iprot->readString(this->success[_i1152]); + xfer += iprot->readString(this->success[_i1172]); } xfer += iprot->readListEnd(); } @@ -19999,10 +20395,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro 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 _iter1153; - for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) + std::vector<std::string> ::const_iterator _iter1173; + for (_iter1173 = this->success.begin(); _iter1173 != this->success.end(); ++_iter1173) { - xfer += oprot->writeString((*_iter1153)); + xfer += oprot->writeString((*_iter1173)); } xfer += oprot->writeListEnd(); } @@ -20047,14 +20443,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1154; - ::apache::thrift::protocol::TType _etyp
<TRUNCATED>