diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index 3e30f56..98fd42b 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -988,6 +988,11 @@ service ThriftHiveMetastore extends fb303.FacebookService throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, 4:InvalidInputException o4) + list exchange_partitions(1:map partitionSpecs, 2:string source_db, + 3:string source_table_name, 4:string dest_db, 5:string dest_table_name) + throws(1:MetaException o1, 2:NoSuchObjectException o2, 3:InvalidObjectException o3, + 4:InvalidInputException o4) + Partition get_partition_with_auth(1:string db_name, 2:string tbl_name, 3:list part_vals, 4: string user_name, 5: list group_names) throws(1:MetaException o1, 2:NoSuchObjectException o2) 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(this->partitionSpecs.size())); + std::map ::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((*(this->partitionSpecs)).size())); + std::map ::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(this->success.size())); + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter914; - for (_iter914 = this->part_vals.begin(); _iter914 != this->part_vals.end(); ++_iter914) + std::vector ::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(this->group_names.size())); - std::vector ::const_iterator _iter915; - for (_iter915 = this->group_names.begin(); _iter915 != this->group_names.end(); ++_iter915) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter916; - for (_iter916 = (*(this->part_vals)).begin(); _iter916 != (*(this->part_vals)).end(); ++_iter916) + std::vector ::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((*(this->group_names)).size())); - std::vector ::const_iterator _iter917; - for (_iter917 = (*(this->group_names)).begin(); _iter917 != (*(this->group_names)).end(); ++_iter917) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter923; - for (_iter923 = this->success.begin(); _iter923 != this->success.end(); ++_iter923) + std::vector ::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(this->group_names.size())); - std::vector ::const_iterator _iter934; - for (_iter934 = this->group_names.begin(); _iter934 != this->group_names.end(); ++_iter934) + std::vector ::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((*(this->group_names)).size())); - std::vector ::const_iterator _iter935; - for (_iter935 = (*(this->group_names)).begin(); _iter935 != (*(this->group_names)).end(); ++_iter935) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter941; - for (_iter941 = this->success.begin(); _iter941 != this->success.end(); ++_iter941) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter952; - for (_iter952 = this->success.begin(); _iter952 != this->success.end(); ++_iter952) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter963; - for (_iter963 = this->success.begin(); _iter963 != this->success.end(); ++_iter963) + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter974; - for (_iter974 = this->part_vals.begin(); _iter974 != this->part_vals.end(); ++_iter974) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter975; - for (_iter975 = (*(this->part_vals)).begin(); _iter975 != (*(this->part_vals)).end(); ++_iter975) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter981; - for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981) + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter997; - for (_iter997 = this->part_vals.begin(); _iter997 != this->part_vals.end(); ++_iter997) + std::vector ::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(this->group_names.size())); - std::vector ::const_iterator _iter998; - for (_iter998 = this->group_names.begin(); _iter998 != this->group_names.end(); ++_iter998) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter999; - for (_iter999 = (*(this->part_vals)).begin(); _iter999 != (*(this->part_vals)).end(); ++_iter999) + std::vector ::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((*(this->group_names)).size())); - std::vector ::const_iterator _iter1000; - for (_iter1000 = (*(this->group_names)).begin(); _iter1000 != (*(this->group_names)).end(); ++_iter1000) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1006; - for (_iter1006 = this->success.begin(); _iter1006 != this->success.end(); ++_iter1006) + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter1017; - for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1018; - for (_iter1018 = (*(this->part_vals)).begin(); _iter1018 != (*(this->part_vals)).end(); ++_iter1018) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1024; - for (_iter1024 = this->success.begin(); _iter1024 != this->success.end(); ++_iter1024) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1035; - for (_iter1035 = this->success.begin(); _iter1035 != this->success.end(); ++_iter1035) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1046; - for (_iter1046 = this->success.begin(); _iter1046 != this->success.end(); ++_iter1046) + std::vector ::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(this->names.size())); - std::vector ::const_iterator _iter1057; - for (_iter1057 = this->names.begin(); _iter1057 != this->names.end(); ++_iter1057) + std::vector ::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((*(this->names)).size())); - std::vector ::const_iterator _iter1058; - for (_iter1058 = (*(this->names)).begin(); _iter1058 != (*(this->names)).end(); ++_iter1058) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1064; - for (_iter1064 = this->success.begin(); _iter1064 != this->success.end(); ++_iter1064) + std::vector ::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(this->new_parts.size())); - std::vector ::const_iterator _iter1075; - for (_iter1075 = this->new_parts.begin(); _iter1075 != this->new_parts.end(); ++_iter1075) + std::vector ::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((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1076; - for (_iter1076 = (*(this->new_parts)).begin(); _iter1076 != (*(this->new_parts)).end(); ++_iter1076) + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter1082; - for (_iter1082 = this->part_vals.begin(); _iter1082 != this->part_vals.end(); ++_iter1082) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1083; - for (_iter1083 = (*(this->part_vals)).begin(); _iter1083 != (*(this->part_vals)).end(); ++_iter1083) + std::vector ::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(this->part_vals.size())); - std::vector ::const_iterator _iter1089; - for (_iter1089 = this->part_vals.begin(); _iter1089 != this->part_vals.end(); ++_iter1089) + std::vector ::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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1090; - for (_iter1090 = (*(this->part_vals)).begin(); _iter1090 != (*(this->part_vals)).end(); ++_iter1090) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1096; - for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) + std::vector ::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(this->success.size())); - std::map ::const_iterator _iter1109; - for (_iter1109 = this->success.begin(); _iter1109 != this->success.end(); ++_iter1109) + std::map ::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(this->part_vals.size())); - std::map ::const_iterator _iter1125; - for (_iter1125 = this->part_vals.begin(); _iter1125 != this->part_vals.end(); ++_iter1125) + std::map ::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((*(this->part_vals)).size())); - std::map ::const_iterator _iter1126; - for (_iter1126 = (*(this->part_vals)).begin(); _iter1126 != (*(this->part_vals)).end(); ++_iter1126) + std::map ::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(this->part_vals.size())); - std::map ::const_iterator _iter1135; - for (_iter1135 = this->part_vals.begin(); _iter1135 != this->part_vals.end(); ++_iter1135) + std::map ::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((*(this->part_vals)).size())); - std::map ::const_iterator _iter1136; - for (_iter1136 = (*(this->part_vals)).begin(); _iter1136 != (*(this->part_vals)).end(); ++_iter1136) + std::map ::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(this->success.size())); - std::vector ::const_iterator _iter1142; - for (_iter1142 = this->success.begin(); _iter1142 != this->success.end(); ++_iter1142) + std::vector ::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(this->success.size())); - std::vector ::const_iterator _iter1153; - for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) + std::vector ::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 _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - (*(this->success)).resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1174; + ::apache::thrift::protocol::TType _etype1177; + xfer += iprot->readListBegin(_etype1177, _size1174); + (*(this->success)).resize(_size1174); + uint32_t _i1178; + for (_i1178 = 0; _i1178 < _size1174; ++_i1178) { - xfer += iprot->readString((*(this->success))[_i1158]); + xfer += iprot->readString((*(this->success))[_i1178]); } xfer += iprot->readListEnd(); } @@ -23627,14 +24023,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1159; - ::apache::thrift::protocol::TType _etype1162; - xfer += iprot->readListBegin(_etype1162, _size1159); - this->success.resize(_size1159); - uint32_t _i1163; - for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + uint32_t _size1179; + ::apache::thrift::protocol::TType _etype1182; + xfer += iprot->readListBegin(_etype1182, _size1179); + this->success.resize(_size1179); + uint32_t _i1183; + for (_i1183 = 0; _i1183 < _size1179; ++_i1183) { - xfer += iprot->readString(this->success[_i1163]); + xfer += iprot->readString(this->success[_i1183]); } xfer += iprot->readListEnd(); } @@ -23673,10 +24069,10 @@ uint32_t ThriftHiveMetastore_get_functions_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1164; - for (_iter1164 = this->success.begin(); _iter1164 != this->success.end(); ++_iter1164) + std::vector ::const_iterator _iter1184; + for (_iter1184 = this->success.begin(); _iter1184 != this->success.end(); ++_iter1184) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1184)); } xfer += oprot->writeListEnd(); } @@ -23721,14 +24117,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - (*(this->success)).resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1185; + ::apache::thrift::protocol::TType _etype1188; + xfer += iprot->readListBegin(_etype1188, _size1185); + (*(this->success)).resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += iprot->readString((*(this->success))[_i1169]); + xfer += iprot->readString((*(this->success))[_i1189]); } xfer += iprot->readListEnd(); } @@ -24688,14 +25084,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1170; - ::apache::thrift::protocol::TType _etype1173; - xfer += iprot->readListBegin(_etype1173, _size1170); - this->success.resize(_size1170); - uint32_t _i1174; - for (_i1174 = 0; _i1174 < _size1170; ++_i1174) + uint32_t _size1190; + ::apache::thrift::protocol::TType _etype1193; + xfer += iprot->readListBegin(_etype1193, _size1190); + this->success.resize(_size1190); + uint32_t _i1194; + for (_i1194 = 0; _i1194 < _size1190; ++_i1194) { - xfer += iprot->readString(this->success[_i1174]); + xfer += iprot->readString(this->success[_i1194]); } xfer += iprot->readListEnd(); } @@ -24734,10 +25130,10 @@ uint32_t ThriftHiveMetastore_get_role_names_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1175; - for (_iter1175 = this->success.begin(); _iter1175 != this->success.end(); ++_iter1175) + std::vector ::const_iterator _iter1195; + for (_iter1195 = this->success.begin(); _iter1195 != this->success.end(); ++_iter1195) { - xfer += oprot->writeString((*_iter1175)); + xfer += oprot->writeString((*_iter1195)); } xfer += oprot->writeListEnd(); } @@ -24782,14 +25178,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1176; - ::apache::thrift::protocol::TType _etype1179; - xfer += iprot->readListBegin(_etype1179, _size1176); - (*(this->success)).resize(_size1176); - uint32_t _i1180; - for (_i1180 = 0; _i1180 < _size1176; ++_i1180) + uint32_t _size1196; + ::apache::thrift::protocol::TType _etype1199; + xfer += iprot->readListBegin(_etype1199, _size1196); + (*(this->success)).resize(_size1196); + uint32_t _i1200; + for (_i1200 = 0; _i1200 < _size1196; ++_i1200) { - xfer += iprot->readString((*(this->success))[_i1180]); + xfer += iprot->readString((*(this->success))[_i1200]); } xfer += iprot->readListEnd(); } @@ -24862,9 +25258,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1181; - xfer += iprot->readI32(ecast1181); - this->principal_type = (PrincipalType::type)ecast1181; + int32_t ecast1201; + xfer += iprot->readI32(ecast1201); + this->principal_type = (PrincipalType::type)ecast1201; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -24880,9 +25276,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1182; - xfer += iprot->readI32(ecast1182); - this->grantorType = (PrincipalType::type)ecast1182; + int32_t ecast1202; + xfer += iprot->readI32(ecast1202); + this->grantorType = (PrincipalType::type)ecast1202; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -25153,9 +25549,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1183; - xfer += iprot->readI32(ecast1183); - this->principal_type = (PrincipalType::type)ecast1183; + int32_t ecast1203; + xfer += iprot->readI32(ecast1203); + this->principal_type = (PrincipalType::type)ecast1203; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -25386,9 +25782,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1184; - xfer += iprot->readI32(ecast1184); - this->principal_type = (PrincipalType::type)ecast1184; + int32_t ecast1204; + xfer += iprot->readI32(ecast1204); + this->principal_type = (PrincipalType::type)ecast1204; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -25477,14 +25873,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->success.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1205; + ::apache::thrift::protocol::TType _etype1208; + xfer += iprot->readListBegin(_etype1208, _size1205); + this->success.resize(_size1205); + uint32_t _i1209; + for (_i1209 = 0; _i1209 < _size1205; ++_i1209) { - xfer += this->success[_i1189].read(iprot); + xfer += this->success[_i1209].read(iprot); } xfer += iprot->readListEnd(); } @@ -25523,10 +25919,10 @@ uint32_t ThriftHiveMetastore_list_roles_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1190; - for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) + std::vector ::const_iterator _iter1210; + for (_iter1210 = this->success.begin(); _iter1210 != this->success.end(); ++_iter1210) { - xfer += (*_iter1190).write(oprot); + xfer += (*_iter1210).write(oprot); } xfer += oprot->writeListEnd(); } @@ -25571,14 +25967,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1191; - ::apache::thrift::protocol::TType _etype1194; - xfer += iprot->readListBegin(_etype1194, _size1191); - (*(this->success)).resize(_size1191); - uint32_t _i1195; - for (_i1195 = 0; _i1195 < _size1191; ++_i1195) + uint32_t _size1211; + ::apache::thrift::protocol::TType _etype1214; + xfer += iprot->readListBegin(_etype1214, _size1211); + (*(this->success)).resize(_size1211); + uint32_t _i1215; + for (_i1215 = 0; _i1215 < _size1211; ++_i1215) { - xfer += (*(this->success))[_i1195].read(iprot); + xfer += (*(this->success))[_i1215].read(iprot); } xfer += iprot->readListEnd(); } @@ -26274,14 +26670,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1196; - ::apache::thrift::protocol::TType _etype1199; - xfer += iprot->readListBegin(_etype1199, _size1196); - this->group_names.resize(_size1196); - uint32_t _i1200; - for (_i1200 = 0; _i1200 < _size1196; ++_i1200) + uint32_t _size1216; + ::apache::thrift::protocol::TType _etype1219; + xfer += iprot->readListBegin(_etype1219, _size1216); + this->group_names.resize(_size1216); + uint32_t _i1220; + for (_i1220 = 0; _i1220 < _size1216; ++_i1220) { - xfer += iprot->readString(this->group_names[_i1200]); + xfer += iprot->readString(this->group_names[_i1220]); } xfer += iprot->readListEnd(); } @@ -26318,10 +26714,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1201; - for (_iter1201 = this->group_names.begin(); _iter1201 != this->group_names.end(); ++_iter1201) + std::vector ::const_iterator _iter1221; + for (_iter1221 = this->group_names.begin(); _iter1221 != this->group_names.end(); ++_iter1221) { - xfer += oprot->writeString((*_iter1201)); + xfer += oprot->writeString((*_iter1221)); } xfer += oprot->writeListEnd(); } @@ -26353,10 +26749,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1202; - for (_iter1202 = (*(this->group_names)).begin(); _iter1202 != (*(this->group_names)).end(); ++_iter1202) + std::vector ::const_iterator _iter1222; + for (_iter1222 = (*(this->group_names)).begin(); _iter1222 != (*(this->group_names)).end(); ++_iter1222) { - xfer += oprot->writeString((*_iter1202)); + xfer += oprot->writeString((*_iter1222)); } xfer += oprot->writeListEnd(); } @@ -26531,9 +26927,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1203; - xfer += iprot->readI32(ecast1203); - this->principal_type = (PrincipalType::type)ecast1203; + int32_t ecast1223; + xfer += iprot->readI32(ecast1223); + this->principal_type = (PrincipalType::type)ecast1223; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -26638,14 +27034,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1204; - ::apache::thrift::protocol::TType _etype1207; - xfer += iprot->readListBegin(_etype1207, _size1204); - this->success.resize(_size1204); - uint32_t _i1208; - for (_i1208 = 0; _i1208 < _size1204; ++_i1208) + uint32_t _size1224; + ::apache::thrift::protocol::TType _etype1227; + xfer += iprot->readListBegin(_etype1227, _size1224); + this->success.resize(_size1224); + uint32_t _i1228; + for (_i1228 = 0; _i1228 < _size1224; ++_i1228) { - xfer += this->success[_i1208].read(iprot); + xfer += this->success[_i1228].read(iprot); } xfer += iprot->readListEnd(); } @@ -26684,10 +27080,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1209; - for (_iter1209 = this->success.begin(); _iter1209 != this->success.end(); ++_iter1209) + std::vector ::const_iterator _iter1229; + for (_iter1229 = this->success.begin(); _iter1229 != this->success.end(); ++_iter1229) { - xfer += (*_iter1209).write(oprot); + xfer += (*_iter1229).write(oprot); } xfer += oprot->writeListEnd(); } @@ -26732,14 +27128,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1210; - ::apache::thrift::protocol::TType _etype1213; - xfer += iprot->readListBegin(_etype1213, _size1210); - (*(this->success)).resize(_size1210); - uint32_t _i1214; - for (_i1214 = 0; _i1214 < _size1210; ++_i1214) + uint32_t _size1230; + ::apache::thrift::protocol::TType _etype1233; + xfer += iprot->readListBegin(_etype1233, _size1230); + (*(this->success)).resize(_size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) { - xfer += (*(this->success))[_i1214].read(iprot); + xfer += (*(this->success))[_i1234].read(iprot); } xfer += iprot->readListEnd(); } @@ -27427,14 +27823,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1215; - ::apache::thrift::protocol::TType _etype1218; - xfer += iprot->readListBegin(_etype1218, _size1215); - this->group_names.resize(_size1215); - uint32_t _i1219; - for (_i1219 = 0; _i1219 < _size1215; ++_i1219) + uint32_t _size1235; + ::apache::thrift::protocol::TType _etype1238; + xfer += iprot->readListBegin(_etype1238, _size1235); + this->group_names.resize(_size1235); + uint32_t _i1239; + for (_i1239 = 0; _i1239 < _size1235; ++_i1239) { - xfer += iprot->readString(this->group_names[_i1219]); + xfer += iprot->readString(this->group_names[_i1239]); } xfer += iprot->readListEnd(); } @@ -27467,10 +27863,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1220; - for (_iter1220 = this->group_names.begin(); _iter1220 != this->group_names.end(); ++_iter1220) + std::vector ::const_iterator _iter1240; + for (_iter1240 = this->group_names.begin(); _iter1240 != this->group_names.end(); ++_iter1240) { - xfer += oprot->writeString((*_iter1220)); + xfer += oprot->writeString((*_iter1240)); } xfer += oprot->writeListEnd(); } @@ -27498,10 +27894,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1221; - for (_iter1221 = (*(this->group_names)).begin(); _iter1221 != (*(this->group_names)).end(); ++_iter1221) + std::vector ::const_iterator _iter1241; + for (_iter1241 = (*(this->group_names)).begin(); _iter1241 != (*(this->group_names)).end(); ++_iter1241) { - xfer += oprot->writeString((*_iter1221)); + xfer += oprot->writeString((*_iter1241)); } xfer += oprot->writeListEnd(); } @@ -27542,14 +27938,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1222; - ::apache::thrift::protocol::TType _etype1225; - xfer += iprot->readListBegin(_etype1225, _size1222); - this->success.resize(_size1222); - uint32_t _i1226; - for (_i1226 = 0; _i1226 < _size1222; ++_i1226) + uint32_t _size1242; + ::apache::thrift::protocol::TType _etype1245; + xfer += iprot->readListBegin(_etype1245, _size1242); + this->success.resize(_size1242); + uint32_t _i1246; + for (_i1246 = 0; _i1246 < _size1242; ++_i1246) { - xfer += iprot->readString(this->success[_i1226]); + xfer += iprot->readString(this->success[_i1246]); } xfer += iprot->readListEnd(); } @@ -27588,10 +27984,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1227; - for (_iter1227 = this->success.begin(); _iter1227 != this->success.end(); ++_iter1227) + std::vector ::const_iterator _iter1247; + for (_iter1247 = this->success.begin(); _iter1247 != this->success.end(); ++_iter1247) { - xfer += oprot->writeString((*_iter1227)); + xfer += oprot->writeString((*_iter1247)); } xfer += oprot->writeListEnd(); } @@ -27636,14 +28032,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1228; - ::apache::thrift::protocol::TType _etype1231; - xfer += iprot->readListBegin(_etype1231, _size1228); - (*(this->success)).resize(_size1228); - uint32_t _i1232; - for (_i1232 = 0; _i1232 < _size1228; ++_i1232) + uint32_t _size1248; + ::apache::thrift::protocol::TType _etype1251; + xfer += iprot->readListBegin(_etype1251, _size1248); + (*(this->success)).resize(_size1248); + uint32_t _i1252; + for (_i1252 = 0; _i1252 < _size1248; ++_i1252) { - xfer += iprot->readString((*(this->success))[_i1232]); + xfer += iprot->readString((*(this->success))[_i1252]); } xfer += iprot->readListEnd(); } @@ -35328,6 +35724,80 @@ void ThriftHiveMetastoreClient::recv_exchange_partition(Partition& _return) throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partition failed: unknown result"); } +void ThriftHiveMetastoreClient::exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partitions(_return); +} + +void ThriftHiveMetastoreClient::send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partitions_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +void ThriftHiveMetastoreClient::recv_exchange_partitions(std::vector & _return) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + ThriftHiveMetastore_exchange_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partitions failed: unknown result"); +} + void ThriftHiveMetastoreClient::get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) { send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names); @@ -43372,6 +43842,72 @@ void ThriftHiveMetastoreProcessor::process_exchange_partition(int32_t seqid, ::a } } +void ThriftHiveMetastoreProcessor::process_exchange_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.exchange_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.exchange_partitions"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + ThriftHiveMetastore_exchange_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.exchange_partitions", bytes); + } + + ThriftHiveMetastore_exchange_partitions_result result; + try { + iface_->exchange_partitions(result.success, args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name); + result.__isset.success = true; + } catch (MetaException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (NoSuchObjectException &o2) { + result.o2 = o2; + result.__isset.o2 = true; + } catch (InvalidObjectException &o3) { + result.o3 = o3; + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = o4; + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.exchange_partitions"); + } + + oprot->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.exchange_partitions", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -52481,6 +53017,110 @@ void ThriftHiveMetastoreConcurrentClient::recv_exchange_partition(Partition& _re } // end while(true) } +void ThriftHiveMetastoreConcurrentClient::exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t seqid = send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + recv_exchange_partitions(_return, seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("exchange_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_exchange_partitions_pargs args; + args.partitionSpecs = &partitionSpecs; + args.source_db = &source_db; + args.source_table_name = &source_table_name; + args.dest_db = &dest_db; + args.dest_table_name = &dest_table_name; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveMetastoreConcurrentClient::recv_exchange_partitions(std::vector & _return, const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("exchange_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + ThriftHiveMetastore_exchange_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + // _return pointer has now been filled + sentry.commit(); + return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "exchange_partitions failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) { int32_t seqid = send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index c8f16a7..3d7cb18 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -66,6 +66,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) = 0; virtual void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals) = 0; virtual void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) = 0; + virtual void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) = 0; virtual void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) = 0; virtual void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0; virtual void get_partitions(std::vector & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) = 0; @@ -320,6 +321,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void exchange_partition(Partition& /* _return */, const std::map & /* partitionSpecs */, const std::string& /* source_db */, const std::string& /* source_table_name */, const std::string& /* dest_db */, const std::string& /* dest_table_name */) { return; } + void exchange_partitions(std::vector & /* _return */, const std::map & /* partitionSpecs */, const std::string& /* source_db */, const std::string& /* source_table_name */, const std::string& /* dest_db */, const std::string& /* dest_table_name */) { + return; + } void get_partition_with_auth(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const std::string& /* user_name */, const std::vector & /* group_names */) { return; } @@ -6328,6 +6332,170 @@ class ThriftHiveMetastore_exchange_partition_presult { }; +typedef struct _ThriftHiveMetastore_exchange_partitions_args__isset { + _ThriftHiveMetastore_exchange_partitions_args__isset() : partitionSpecs(false), source_db(false), source_table_name(false), dest_db(false), dest_table_name(false) {} + bool partitionSpecs :1; + bool source_db :1; + bool source_table_name :1; + bool dest_db :1; + bool dest_table_name :1; +} _ThriftHiveMetastore_exchange_partitions_args__isset; + +class ThriftHiveMetastore_exchange_partitions_args { + public: + + ThriftHiveMetastore_exchange_partitions_args(const ThriftHiveMetastore_exchange_partitions_args&); + ThriftHiveMetastore_exchange_partitions_args& operator=(const ThriftHiveMetastore_exchange_partitions_args&); + ThriftHiveMetastore_exchange_partitions_args() : source_db(), source_table_name(), dest_db(), dest_table_name() { + } + + virtual ~ThriftHiveMetastore_exchange_partitions_args() throw(); + std::map partitionSpecs; + std::string source_db; + std::string source_table_name; + std::string dest_db; + std::string dest_table_name; + + _ThriftHiveMetastore_exchange_partitions_args__isset __isset; + + void __set_partitionSpecs(const std::map & val); + + void __set_source_db(const std::string& val); + + void __set_source_table_name(const std::string& val); + + void __set_dest_db(const std::string& val); + + void __set_dest_table_name(const std::string& val); + + bool operator == (const ThriftHiveMetastore_exchange_partitions_args & rhs) const + { + if (!(partitionSpecs == rhs.partitionSpecs)) + return false; + if (!(source_db == rhs.source_db)) + return false; + if (!(source_table_name == rhs.source_table_name)) + return false; + if (!(dest_db == rhs.dest_db)) + return false; + if (!(dest_table_name == rhs.dest_table_name)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_exchange_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_exchange_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_exchange_partitions_pargs() throw(); + const std::map * partitionSpecs; + const std::string* source_db; + const std::string* source_table_name; + const std::string* dest_db; + const std::string* dest_table_name; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partitions_result__isset { + _ThriftHiveMetastore_exchange_partitions_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partitions_result__isset; + +class ThriftHiveMetastore_exchange_partitions_result { + public: + + ThriftHiveMetastore_exchange_partitions_result(const ThriftHiveMetastore_exchange_partitions_result&); + ThriftHiveMetastore_exchange_partitions_result& operator=(const ThriftHiveMetastore_exchange_partitions_result&); + ThriftHiveMetastore_exchange_partitions_result() { + } + + virtual ~ThriftHiveMetastore_exchange_partitions_result() throw(); + std::vector success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partitions_result__isset __isset; + + void __set_success(const std::vector & val); + + void __set_o1(const MetaException& val); + + void __set_o2(const NoSuchObjectException& val); + + void __set_o3(const InvalidObjectException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_exchange_partitions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + if (!(o4 == rhs.o4)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_exchange_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_exchange_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_exchange_partitions_presult__isset { + _ThriftHiveMetastore_exchange_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_exchange_partitions_presult__isset; + +class ThriftHiveMetastore_exchange_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_exchange_partitions_presult() throw(); + std::vector * success; + MetaException o1; + NoSuchObjectException o2; + InvalidObjectException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_exchange_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_partition_with_auth_args__isset { _ThriftHiveMetastore_get_partition_with_auth_args__isset() : db_name(false), tbl_name(false), part_vals(false), user_name(false), group_names(false) {} bool db_name :1; @@ -16868,6 +17036,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); void send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); void recv_exchange_partition(Partition& _return); + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partitions(std::vector & _return); void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); void recv_get_partition_with_auth(Partition& _return); @@ -17177,6 +17348,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_drop_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_exchange_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_exchange_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -17310,6 +17482,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["drop_partitions_req"] = &ThriftHiveMetastoreProcessor::process_drop_partitions_req; processMap_["get_partition"] = &ThriftHiveMetastoreProcessor::process_get_partition; processMap_["exchange_partition"] = &ThriftHiveMetastoreProcessor::process_exchange_partition; + processMap_["exchange_partitions"] = &ThriftHiveMetastoreProcessor::process_exchange_partitions; processMap_["get_partition_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partition_with_auth; processMap_["get_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_get_partition_by_name; processMap_["get_partitions"] = &ThriftHiveMetastoreProcessor::process_get_partitions; @@ -17849,6 +18022,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->exchange_partitions(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + } + ifaces_[i]->exchange_partitions(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + return; + } + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) { size_t sz = ifaces_.size(); size_t i = 0; @@ -18815,6 +18998,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void exchange_partition(Partition& _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); int32_t send_exchange_partition(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); void recv_exchange_partition(Partition& _return, const int32_t seqid); + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + int32_t send_exchange_partitions(const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name); + void recv_exchange_partitions(std::vector & _return, const int32_t seqid); void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); int32_t send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names); void recv_get_partition_with_auth(Partition& _return, const int32_t seqid); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index 9eca65c..a395729 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -242,6 +242,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("exchange_partition\n"); } + void exchange_partitions(std::vector & _return, const std::map & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name) { + // Your implementation goes here + printf("exchange_partitions\n"); + } + void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const std::string& user_name, const std::vector & group_names) { // Your implementation goes here printf("get_partition_with_auth\n"); diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 0c67416..3bc7e10 100644 --- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -130,6 +130,8 @@ public Partition exchange_partition(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, org.apache.thrift.TException; + public List exchange_partitions(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, org.apache.thrift.TException; + public Partition get_partition_with_auth(String db_name, String tbl_name, List part_vals, String user_name, List group_names) throws MetaException, NoSuchObjectException, org.apache.thrift.TException; public Partition get_partition_by_name(String db_name, String tbl_name, String part_name) throws MetaException, NoSuchObjectException, org.apache.thrift.TException; @@ -392,6 +394,8 @@ public void exchange_partition(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void exchange_partitions(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_partition_with_auth(String db_name, String tbl_name, List part_vals, String user_name, List group_names, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void get_partition_by_name(String db_name, String tbl_name, String part_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1937,6 +1941,45 @@ public Partition recv_exchange_partition() throws MetaException, NoSuchObjectExc throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exchange_partition failed: unknown result"); } + public List exchange_partitions(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, org.apache.thrift.TException + { + send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name); + return recv_exchange_partitions(); + } + + public void send_exchange_partitions(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name) throws org.apache.thrift.TException + { + exchange_partitions_args args = new exchange_partitions_args(); + args.setPartitionSpecs(partitionSpecs); + args.setSource_db(source_db); + args.setSource_table_name(source_table_name); + args.setDest_db(dest_db); + args.setDest_table_name(dest_table_name); + sendBase("exchange_partitions", args); + } + + public List recv_exchange_partitions() throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, org.apache.thrift.TException + { + exchange_partitions_result result = new exchange_partitions_result(); + receiveBase(result, "exchange_partitions"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + if (result.o4 != null) { + throw result.o4; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "exchange_partitions failed: unknown result"); + } + public Partition get_partition_with_auth(String db_name, String tbl_name, List part_vals, String user_name, List group_names) throws MetaException, NoSuchObjectException, org.apache.thrift.TException { send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names); @@ -5953,6 +5996,50 @@ public Partition getResult() throws MetaException, NoSuchObjectException, Invali } } + public void exchange_partitions(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + exchange_partitions_call method_call = new exchange_partitions_call(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class exchange_partitions_call extends org.apache.thrift.async.TAsyncMethodCall { + private Map partitionSpecs; + private String source_db; + private String source_table_name; + private String dest_db; + private String dest_table_name; + public exchange_partitions_call(Map partitionSpecs, String source_db, String source_table_name, String dest_db, String dest_table_name, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.partitionSpecs = partitionSpecs; + this.source_db = source_db; + this.source_table_name = source_table_name; + this.dest_db = dest_db; + this.dest_table_name = dest_table_name; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("exchange_partitions", org.apache.thrift.protocol.TMessageType.CALL, 0)); + exchange_partitions_args args = new exchange_partitions_args(); + args.setPartitionSpecs(partitionSpecs); + args.setSource_db(source_db); + args.setSource_table_name(source_table_name); + args.setDest_db(dest_db); + args.setDest_table_name(dest_table_name); + args.write(prot); + prot.writeMessageEnd(); + } + + public List getResult() throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_exchange_partitions(); + } + } + public void get_partition_with_auth(String db_name, String tbl_name, List part_vals, String user_name, List group_names, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_partition_with_auth_call method_call = new get_partition_with_auth_call(db_name, tbl_name, part_vals, user_name, group_names, resultHandler, this, ___protocolFactory, ___transport); @@ -8997,6 +9084,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public exchange_partitions() { + super("exchange_partitions"); + } + + public exchange_partitions_args getEmptyArgsInstance() { + return new exchange_partitions_args(); + } + + protected boolean isOneway() { + return false; + } + + public exchange_partitions_result getResult(I iface, exchange_partitions_args args) throws org.apache.thrift.TException { + exchange_partitions_result result = new exchange_partitions_result(); + try { + result.success = iface.exchange_partitions(args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name); + } catch (MetaException o1) { + result.o1 = o1; + } catch (NoSuchObjectException o2) { + result.o2 = o2; + } catch (InvalidObjectException o3) { + result.o3 = o3; + } catch (InvalidInputException o4) { + result.o4 = o4; + } + return result; + } + } + public static class get_partition_with_auth extends org.apache.thrift.ProcessFunction { public get_partition_with_auth() { super("get_partition_with_auth"); @@ -12463,6 +12581,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public get_partition_with_auth() { - super("get_partition_with_auth"); + public static class exchange_partitions extends org.apache.thrift.AsyncProcessFunction> { + public exchange_partitions() { + super("exchange_partitions"); } - public get_partition_with_auth_args getEmptyArgsInstance() { - return new get_partition_with_auth_args(); + public exchange_partitions_args getEmptyArgsInstance() { + return new exchange_partitions_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Partition o) { - get_partition_with_auth_result result = new get_partition_with_auth_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + exchange_partitions_result result = new exchange_partitions_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15387,7 +15506,7 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partition_with_auth_result result = new get_partition_with_auth_result(); + exchange_partitions_result result = new exchange_partitions_result(); if (e instanceof MetaException) { result.o1 = (MetaException) e; result.setO1IsSet(true); @@ -15398,6 +15517,16 @@ else if (e instanceof NoSuchObjectException) { result.setO2IsSet(true); msg = result; } + else if (e instanceof InvalidObjectException) { + result.o3 = (InvalidObjectException) e; + result.setO3IsSet(true); + msg = result; + } + else if (e instanceof InvalidInputException) { + result.o4 = (InvalidInputException) e; + result.setO4IsSet(true); + msg = result; + } else { msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; @@ -15418,25 +15547,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partition_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_partition_with_auth(args.db_name, args.tbl_name, args.part_vals, args.user_name, args.group_names,resultHandler); + public void start(I iface, exchange_partitions_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.exchange_partitions(args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name,resultHandler); } } - public static class get_partition_by_name extends org.apache.thrift.AsyncProcessFunction { - public get_partition_by_name() { - super("get_partition_by_name"); + public static class get_partition_with_auth extends org.apache.thrift.AsyncProcessFunction { + public get_partition_with_auth() { + super("get_partition_with_auth"); } - public get_partition_by_name_args getEmptyArgsInstance() { - return new get_partition_by_name_args(); + public get_partition_with_auth_args getEmptyArgsInstance() { + return new get_partition_with_auth_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(Partition o) { - get_partition_by_name_result result = new get_partition_by_name_result(); + get_partition_with_auth_result result = new get_partition_with_auth_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15449,7 +15578,7 @@ public void onComplete(Partition o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partition_by_name_result result = new get_partition_by_name_result(); + get_partition_with_auth_result result = new get_partition_with_auth_result(); if (e instanceof MetaException) { result.o1 = (MetaException) e; result.setO1IsSet(true); @@ -15480,25 +15609,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); + public void start(I iface, get_partition_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_partition_with_auth(args.db_name, args.tbl_name, args.part_vals, args.user_name, args.group_names,resultHandler); } } - public static class get_partitions extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions() { - super("get_partitions"); + public static class get_partition_by_name extends org.apache.thrift.AsyncProcessFunction { + public get_partition_by_name() { + super("get_partition_by_name"); } - public get_partitions_args getEmptyArgsInstance() { - return new get_partitions_args(); + public get_partition_by_name_args getEmptyArgsInstance() { + return new get_partition_by_name_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partitions_result result = new get_partitions_result(); + return new AsyncMethodCallback() { + public void onComplete(Partition o) { + get_partition_by_name_result result = new get_partition_by_name_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15511,14 +15640,14 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_result result = new get_partitions_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; + get_partition_by_name_result result = new get_partition_by_name_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; result.setO2IsSet(true); msg = result; } @@ -15542,87 +15671,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions(args.db_name, args.tbl_name, args.max_parts,resultHandler); + public void start(I iface, get_partition_by_name_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_partition_by_name(args.db_name, args.tbl_name, args.part_name,resultHandler); } } - public static class get_partitions_with_auth extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_with_auth() { - super("get_partitions_with_auth"); + public static class get_partitions extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions() { + super("get_partitions"); } - public get_partitions_with_auth_args getEmptyArgsInstance() { - return new get_partitions_with_auth_args(); + public get_partitions_args getEmptyArgsInstance() { + return new get_partitions_args(); } public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback>() { public void onComplete(List o) { - get_partitions_with_auth_result result = new get_partitions_with_auth_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_partitions_with_auth_result result = new get_partitions_with_auth_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_partitions_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_with_auth(args.db_name, args.tbl_name, args.max_parts, args.user_name, args.group_names,resultHandler); - } - } - - public static class get_partitions_pspec extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_pspec() { - super("get_partitions_pspec"); - } - - public get_partitions_pspec_args getEmptyArgsInstance() { - return new get_partitions_pspec_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partitions_pspec_result result = new get_partitions_pspec_result(); + get_partitions_result result = new get_partitions_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15635,7 +15702,7 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_pspec_result result = new get_partitions_pspec_result(); + get_partitions_result result = new get_partitions_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -15666,144 +15733,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_pspec(args.db_name, args.tbl_name, args.max_parts,resultHandler); - } - } - - public static class get_partition_names extends org.apache.thrift.AsyncProcessFunction> { - public get_partition_names() { - super("get_partition_names"); - } - - public get_partition_names_args getEmptyArgsInstance() { - return new get_partition_names_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partition_names_result result = new get_partition_names_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_partition_names_result result = new get_partition_names_result(); - if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_partition_names_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partition_names(args.db_name, args.tbl_name, args.max_parts,resultHandler); - } - } - - public static class get_partitions_ps extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_ps() { - super("get_partitions_ps"); - } - - public get_partitions_ps_args getEmptyArgsInstance() { - return new get_partitions_ps_args(); - } - - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partitions_ps_result result = new get_partitions_ps_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_partitions_ps_result result = new get_partitions_ps_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof NoSuchObjectException) { - result.o2 = (NoSuchObjectException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_partitions_ps_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_ps(args.db_name, args.tbl_name, args.part_vals, args.max_parts,resultHandler); + public void start(I iface, get_partitions_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions(args.db_name, args.tbl_name, args.max_parts,resultHandler); } } - public static class get_partitions_ps_with_auth extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_ps_with_auth() { - super("get_partitions_ps_with_auth"); + public static class get_partitions_with_auth extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_with_auth() { + super("get_partitions_with_auth"); } - public get_partitions_ps_with_auth_args getEmptyArgsInstance() { - return new get_partitions_ps_with_auth_args(); + public get_partitions_with_auth_args getEmptyArgsInstance() { + return new get_partitions_with_auth_args(); } public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback>() { public void onComplete(List o) { - get_partitions_ps_with_auth_result result = new get_partitions_ps_with_auth_result(); + get_partitions_with_auth_result result = new get_partitions_with_auth_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15816,7 +15764,7 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_ps_with_auth_result result = new get_partitions_ps_with_auth_result(); + get_partitions_with_auth_result result = new get_partitions_with_auth_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -15847,25 +15795,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_ps_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_ps_with_auth(args.db_name, args.tbl_name, args.part_vals, args.max_parts, args.user_name, args.group_names,resultHandler); + public void start(I iface, get_partitions_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_with_auth(args.db_name, args.tbl_name, args.max_parts, args.user_name, args.group_names,resultHandler); } } - public static class get_partition_names_ps extends org.apache.thrift.AsyncProcessFunction> { - public get_partition_names_ps() { - super("get_partition_names_ps"); + public static class get_partitions_pspec extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_pspec() { + super("get_partitions_pspec"); } - public get_partition_names_ps_args getEmptyArgsInstance() { - return new get_partition_names_ps_args(); + public get_partitions_pspec_args getEmptyArgsInstance() { + return new get_partitions_pspec_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partition_names_ps_result result = new get_partition_names_ps_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partitions_pspec_result result = new get_partitions_pspec_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15878,14 +15826,14 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partition_names_ps_result result = new get_partition_names_ps_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; + get_partitions_pspec_result result = new get_partitions_pspec_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof NoSuchObjectException) { - result.o2 = (NoSuchObjectException) e; + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; result.setO2IsSet(true); msg = result; } @@ -15909,25 +15857,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partition_names_ps_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partition_names_ps(args.db_name, args.tbl_name, args.part_vals, args.max_parts,resultHandler); + public void start(I iface, get_partitions_pspec_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_pspec(args.db_name, args.tbl_name, args.max_parts,resultHandler); } } - public static class get_partitions_by_filter extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_by_filter() { - super("get_partitions_by_filter"); + public static class get_partition_names extends org.apache.thrift.AsyncProcessFunction> { + public get_partition_names() { + super("get_partition_names"); } - public get_partitions_by_filter_args getEmptyArgsInstance() { - return new get_partitions_by_filter_args(); + public get_partition_names_args getEmptyArgsInstance() { + return new get_partition_names_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partitions_by_filter_result result = new get_partitions_by_filter_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partition_names_result result = new get_partition_names_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -15940,14 +15888,9 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_by_filter_result result = new get_partitions_by_filter_result(); + get_partition_names_result result = new get_partition_names_result(); if (e instanceof MetaException) { - result.o1 = (MetaException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof NoSuchObjectException) { - result.o2 = (NoSuchObjectException) e; + result.o2 = (MetaException) e; result.setO2IsSet(true); msg = result; } @@ -15971,25 +15914,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_by_filter(args.db_name, args.tbl_name, args.filter, args.max_parts,resultHandler); + public void start(I iface, get_partition_names_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partition_names(args.db_name, args.tbl_name, args.max_parts,resultHandler); } } - public static class get_part_specs_by_filter extends org.apache.thrift.AsyncProcessFunction> { - public get_part_specs_by_filter() { - super("get_part_specs_by_filter"); + public static class get_partitions_ps extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_ps() { + super("get_partitions_ps"); } - public get_part_specs_by_filter_args getEmptyArgsInstance() { - return new get_part_specs_by_filter_args(); + public get_partitions_ps_args getEmptyArgsInstance() { + return new get_partitions_ps_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_part_specs_by_filter_result result = new get_part_specs_by_filter_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partitions_ps_result result = new get_partitions_ps_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16002,7 +15945,7 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_part_specs_by_filter_result result = new get_part_specs_by_filter_result(); + get_partitions_ps_result result = new get_partitions_ps_result(); if (e instanceof MetaException) { result.o1 = (MetaException) e; result.setO1IsSet(true); @@ -16033,25 +15976,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_part_specs_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_part_specs_by_filter(args.db_name, args.tbl_name, args.filter, args.max_parts,resultHandler); + public void start(I iface, get_partitions_ps_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_ps(args.db_name, args.tbl_name, args.part_vals, args.max_parts,resultHandler); } } - public static class get_partitions_by_expr extends org.apache.thrift.AsyncProcessFunction { - public get_partitions_by_expr() { - super("get_partitions_by_expr"); + public static class get_partitions_ps_with_auth extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_ps_with_auth() { + super("get_partitions_ps_with_auth"); } - public get_partitions_by_expr_args getEmptyArgsInstance() { - return new get_partitions_by_expr_args(); + public get_partitions_ps_with_auth_args getEmptyArgsInstance() { + return new get_partitions_ps_with_auth_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(PartitionsByExprResult o) { - get_partitions_by_expr_result result = new get_partitions_by_expr_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partitions_ps_with_auth_result result = new get_partitions_ps_with_auth_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16064,14 +16007,14 @@ public void onComplete(PartitionsByExprResult o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_by_expr_result result = new get_partitions_by_expr_result(); - if (e instanceof MetaException) { - result.o1 = (MetaException) e; + get_partitions_ps_with_auth_result result = new get_partitions_ps_with_auth_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof NoSuchObjectException) { - result.o2 = (NoSuchObjectException) e; + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; result.setO2IsSet(true); msg = result; } @@ -16095,25 +16038,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_by_expr_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_partitions_by_expr(args.req,resultHandler); + public void start(I iface, get_partitions_ps_with_auth_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_ps_with_auth(args.db_name, args.tbl_name, args.part_vals, args.max_parts, args.user_name, args.group_names,resultHandler); } } - public static class get_partitions_by_names extends org.apache.thrift.AsyncProcessFunction> { - public get_partitions_by_names() { - super("get_partitions_by_names"); + public static class get_partition_names_ps extends org.apache.thrift.AsyncProcessFunction> { + public get_partition_names_ps() { + super("get_partition_names_ps"); } - public get_partitions_by_names_args getEmptyArgsInstance() { - return new get_partitions_by_names_args(); + public get_partition_names_ps_args getEmptyArgsInstance() { + return new get_partition_names_ps_args(); } - public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback>() { - public void onComplete(List o) { - get_partitions_by_names_result result = new get_partitions_by_names_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partition_names_ps_result result = new get_partition_names_ps_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -16126,7 +16069,7 @@ public void onComplete(List o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partitions_by_names_result result = new get_partitions_by_names_result(); + get_partition_names_ps_result result = new get_partition_names_ps_result(); if (e instanceof MetaException) { result.o1 = (MetaException) e; result.setO1IsSet(true); @@ -16157,25 +16100,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partitions_by_names_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { - iface.get_partitions_by_names(args.db_name, args.tbl_name, args.names,resultHandler); + public void start(I iface, get_partition_names_ps_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partition_names_ps(args.db_name, args.tbl_name, args.part_vals, args.max_parts,resultHandler); } } - public static class alter_partition extends org.apache.thrift.AsyncProcessFunction { - public alter_partition() { - super("alter_partition"); + public static class get_partitions_by_filter extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_by_filter() { + super("get_partitions_by_filter"); } - public alter_partition_args getEmptyArgsInstance() { - return new alter_partition_args(); + public get_partitions_by_filter_args getEmptyArgsInstance() { + return new get_partitions_by_filter_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_partition_result result = new alter_partition_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partitions_by_filter_result result = new get_partitions_by_filter_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16187,14 +16131,14 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_partition_result result = new alter_partition_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_partitions_by_filter_result result = new get_partitions_by_filter_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; result.setO2IsSet(true); msg = result; } @@ -16218,25 +16162,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_partition(args.db_name, args.tbl_name, args.new_part,resultHandler); + public void start(I iface, get_partitions_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_by_filter(args.db_name, args.tbl_name, args.filter, args.max_parts,resultHandler); } } - public static class alter_partitions extends org.apache.thrift.AsyncProcessFunction { - public alter_partitions() { - super("alter_partitions"); + public static class get_part_specs_by_filter extends org.apache.thrift.AsyncProcessFunction> { + public get_part_specs_by_filter() { + super("get_part_specs_by_filter"); } - public alter_partitions_args getEmptyArgsInstance() { - return new alter_partitions_args(); + public get_part_specs_by_filter_args getEmptyArgsInstance() { + return new get_part_specs_by_filter_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_partitions_result result = new alter_partitions_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_part_specs_by_filter_result result = new get_part_specs_by_filter_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16248,14 +16193,14 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_partitions_result result = new alter_partitions_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_part_specs_by_filter_result result = new get_part_specs_by_filter_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; result.setO2IsSet(true); msg = result; } @@ -16279,25 +16224,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_partitions(args.db_name, args.tbl_name, args.new_parts,resultHandler); + public void start(I iface, get_part_specs_by_filter_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_part_specs_by_filter(args.db_name, args.tbl_name, args.filter, args.max_parts,resultHandler); } } - public static class alter_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { - public alter_partition_with_environment_context() { - super("alter_partition_with_environment_context"); + public static class get_partitions_by_expr extends org.apache.thrift.AsyncProcessFunction { + public get_partitions_by_expr() { + super("get_partitions_by_expr"); } - public alter_partition_with_environment_context_args getEmptyArgsInstance() { - return new alter_partition_with_environment_context_args(); + public get_partitions_by_expr_args getEmptyArgsInstance() { + return new get_partitions_by_expr_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - alter_partition_with_environment_context_result result = new alter_partition_with_environment_context_result(); + return new AsyncMethodCallback() { + public void onComplete(PartitionsByExprResult o) { + get_partitions_by_expr_result result = new get_partitions_by_expr_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16309,14 +16255,14 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - alter_partition_with_environment_context_result result = new alter_partition_with_environment_context_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_partitions_by_expr_result result = new get_partitions_by_expr_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; result.setO2IsSet(true); msg = result; } @@ -16340,25 +16286,26 @@ protected boolean isOneway() { return false; } - public void start(I iface, alter_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.alter_partition_with_environment_context(args.db_name, args.tbl_name, args.new_part, args.environment_context,resultHandler); + public void start(I iface, get_partitions_by_expr_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_partitions_by_expr(args.req,resultHandler); } } - public static class rename_partition extends org.apache.thrift.AsyncProcessFunction { - public rename_partition() { - super("rename_partition"); + public static class get_partitions_by_names extends org.apache.thrift.AsyncProcessFunction> { + public get_partitions_by_names() { + super("get_partitions_by_names"); } - public rename_partition_args getEmptyArgsInstance() { - return new rename_partition_args(); + public get_partitions_by_names_args getEmptyArgsInstance() { + return new get_partitions_by_names_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Void o) { - rename_partition_result result = new rename_partition_result(); + return new AsyncMethodCallback>() { + public void onComplete(List o) { + get_partitions_by_names_result result = new get_partitions_by_names_result(); + result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -16370,14 +16317,258 @@ public void onComplete(Void o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - rename_partition_result result = new rename_partition_result(); - if (e instanceof InvalidOperationException) { - result.o1 = (InvalidOperationException) e; + get_partitions_by_names_result result = new get_partitions_by_names_result(); + if (e instanceof MetaException) { + result.o1 = (MetaException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof NoSuchObjectException) { + result.o2 = (NoSuchObjectException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_partitions_by_names_args args, org.apache.thrift.async.AsyncMethodCallback> resultHandler) throws TException { + iface.get_partitions_by_names(args.db_name, args.tbl_name, args.names,resultHandler); + } + } + + public static class alter_partition extends org.apache.thrift.AsyncProcessFunction { + public alter_partition() { + super("alter_partition"); + } + + public alter_partition_args getEmptyArgsInstance() { + return new alter_partition_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_partition_result result = new alter_partition_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + alter_partition_result result = new alter_partition_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, alter_partition_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_partition(args.db_name, args.tbl_name, args.new_part,resultHandler); + } + } + + public static class alter_partitions extends org.apache.thrift.AsyncProcessFunction { + public alter_partitions() { + super("alter_partitions"); + } + + public alter_partitions_args getEmptyArgsInstance() { + return new alter_partitions_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_partitions_result result = new alter_partitions_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + alter_partitions_result result = new alter_partitions_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, alter_partitions_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_partitions(args.db_name, args.tbl_name, args.new_parts,resultHandler); + } + } + + public static class alter_partition_with_environment_context extends org.apache.thrift.AsyncProcessFunction { + public alter_partition_with_environment_context() { + super("alter_partition_with_environment_context"); + } + + public alter_partition_with_environment_context_args getEmptyArgsInstance() { + return new alter_partition_with_environment_context_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + alter_partition_with_environment_context_result result = new alter_partition_with_environment_context_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + alter_partition_with_environment_context_result result = new alter_partition_with_environment_context_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, alter_partition_with_environment_context_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.alter_partition_with_environment_context(args.db_name, args.tbl_name, args.new_part, args.environment_context,resultHandler); + } + } + + public static class rename_partition extends org.apache.thrift.AsyncProcessFunction { + public rename_partition() { + super("rename_partition"); + } + + public rename_partition_args getEmptyArgsInstance() { + return new rename_partition_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Void o) { + rename_partition_result result = new rename_partition_result(); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + rename_partition_result result = new rename_partition_result(); + if (e instanceof InvalidOperationException) { + result.o1 = (InvalidOperationException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; result.setO2IsSet(true); msg = result; } @@ -67468,7 +67659,1554 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("get_partition_result("); + StringBuilder sb = new StringBuilder("get_partition_result("); + boolean first = true; + + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class get_partition_resultStandardSchemeFactory implements SchemeFactory { + public get_partition_resultStandardScheme getScheme() { + return new get_partition_resultStandardScheme(); + } + } + + private static class get_partition_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.success = new Partition(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new NoSuchObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class get_partition_resultTupleSchemeFactory implements SchemeFactory { + public get_partition_resultTupleScheme getScheme() { + return new get_partition_resultTupleScheme(); + } + } + + private static class get_partition_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + if (struct.isSetO2()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = new Partition(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new MetaException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new NoSuchObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + } + } + + } + + public static class exchange_partition_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partition_args"); + + private static final org.apache.thrift.protocol.TField PARTITION_SPECS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionSpecs", org.apache.thrift.protocol.TType.MAP, (short)1); + private static final org.apache.thrift.protocol.TField SOURCE_DB_FIELD_DESC = new org.apache.thrift.protocol.TField("source_db", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField SOURCE_TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("source_table_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField DEST_DB_FIELD_DESC = new org.apache.thrift.protocol.TField("dest_db", org.apache.thrift.protocol.TType.STRING, (short)4); + private static final org.apache.thrift.protocol.TField DEST_TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dest_table_name", org.apache.thrift.protocol.TType.STRING, (short)5); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new exchange_partition_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new exchange_partition_argsTupleSchemeFactory()); + } + + private Map partitionSpecs; // required + private String source_db; // required + private String source_table_name; // required + private String dest_db; // required + private String dest_table_name; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PARTITION_SPECS((short)1, "partitionSpecs"), + SOURCE_DB((short)2, "source_db"), + SOURCE_TABLE_NAME((short)3, "source_table_name"), + DEST_DB((short)4, "dest_db"), + DEST_TABLE_NAME((short)5, "dest_table_name"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // PARTITION_SPECS + return PARTITION_SPECS; + case 2: // SOURCE_DB + return SOURCE_DB; + case 3: // SOURCE_TABLE_NAME + return SOURCE_TABLE_NAME; + case 4: // DEST_DB + return DEST_DB; + case 5: // DEST_TABLE_NAME + return DEST_TABLE_NAME; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PARTITION_SPECS, new org.apache.thrift.meta_data.FieldMetaData("partitionSpecs", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.SOURCE_DB, new org.apache.thrift.meta_data.FieldMetaData("source_db", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.SOURCE_TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("source_table_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DEST_DB, new org.apache.thrift.meta_data.FieldMetaData("dest_db", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DEST_TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("dest_table_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partition_args.class, metaDataMap); + } + + public exchange_partition_args() { + } + + public exchange_partition_args( + Map partitionSpecs, + String source_db, + String source_table_name, + String dest_db, + String dest_table_name) + { + this(); + this.partitionSpecs = partitionSpecs; + this.source_db = source_db; + this.source_table_name = source_table_name; + this.dest_db = dest_db; + this.dest_table_name = dest_table_name; + } + + /** + * Performs a deep copy on other. + */ + public exchange_partition_args(exchange_partition_args other) { + if (other.isSetPartitionSpecs()) { + Map __this__partitionSpecs = new HashMap(other.partitionSpecs); + this.partitionSpecs = __this__partitionSpecs; + } + if (other.isSetSource_db()) { + this.source_db = other.source_db; + } + if (other.isSetSource_table_name()) { + this.source_table_name = other.source_table_name; + } + if (other.isSetDest_db()) { + this.dest_db = other.dest_db; + } + if (other.isSetDest_table_name()) { + this.dest_table_name = other.dest_table_name; + } + } + + public exchange_partition_args deepCopy() { + return new exchange_partition_args(this); + } + + @Override + public void clear() { + this.partitionSpecs = null; + this.source_db = null; + this.source_table_name = null; + this.dest_db = null; + this.dest_table_name = null; + } + + public int getPartitionSpecsSize() { + return (this.partitionSpecs == null) ? 0 : this.partitionSpecs.size(); + } + + public void putToPartitionSpecs(String key, String val) { + if (this.partitionSpecs == null) { + this.partitionSpecs = new HashMap(); + } + this.partitionSpecs.put(key, val); + } + + public Map getPartitionSpecs() { + return this.partitionSpecs; + } + + public void setPartitionSpecs(Map partitionSpecs) { + this.partitionSpecs = partitionSpecs; + } + + public void unsetPartitionSpecs() { + this.partitionSpecs = null; + } + + /** Returns true if field partitionSpecs is set (has been assigned a value) and false otherwise */ + public boolean isSetPartitionSpecs() { + return this.partitionSpecs != null; + } + + public void setPartitionSpecsIsSet(boolean value) { + if (!value) { + this.partitionSpecs = null; + } + } + + public String getSource_db() { + return this.source_db; + } + + public void setSource_db(String source_db) { + this.source_db = source_db; + } + + public void unsetSource_db() { + this.source_db = null; + } + + /** Returns true if field source_db is set (has been assigned a value) and false otherwise */ + public boolean isSetSource_db() { + return this.source_db != null; + } + + public void setSource_dbIsSet(boolean value) { + if (!value) { + this.source_db = null; + } + } + + public String getSource_table_name() { + return this.source_table_name; + } + + public void setSource_table_name(String source_table_name) { + this.source_table_name = source_table_name; + } + + public void unsetSource_table_name() { + this.source_table_name = null; + } + + /** Returns true if field source_table_name is set (has been assigned a value) and false otherwise */ + public boolean isSetSource_table_name() { + return this.source_table_name != null; + } + + public void setSource_table_nameIsSet(boolean value) { + if (!value) { + this.source_table_name = null; + } + } + + public String getDest_db() { + return this.dest_db; + } + + public void setDest_db(String dest_db) { + this.dest_db = dest_db; + } + + public void unsetDest_db() { + this.dest_db = null; + } + + /** Returns true if field dest_db is set (has been assigned a value) and false otherwise */ + public boolean isSetDest_db() { + return this.dest_db != null; + } + + public void setDest_dbIsSet(boolean value) { + if (!value) { + this.dest_db = null; + } + } + + public String getDest_table_name() { + return this.dest_table_name; + } + + public void setDest_table_name(String dest_table_name) { + this.dest_table_name = dest_table_name; + } + + public void unsetDest_table_name() { + this.dest_table_name = null; + } + + /** Returns true if field dest_table_name is set (has been assigned a value) and false otherwise */ + public boolean isSetDest_table_name() { + return this.dest_table_name != null; + } + + public void setDest_table_nameIsSet(boolean value) { + if (!value) { + this.dest_table_name = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PARTITION_SPECS: + if (value == null) { + unsetPartitionSpecs(); + } else { + setPartitionSpecs((Map)value); + } + break; + + case SOURCE_DB: + if (value == null) { + unsetSource_db(); + } else { + setSource_db((String)value); + } + break; + + case SOURCE_TABLE_NAME: + if (value == null) { + unsetSource_table_name(); + } else { + setSource_table_name((String)value); + } + break; + + case DEST_DB: + if (value == null) { + unsetDest_db(); + } else { + setDest_db((String)value); + } + break; + + case DEST_TABLE_NAME: + if (value == null) { + unsetDest_table_name(); + } else { + setDest_table_name((String)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PARTITION_SPECS: + return getPartitionSpecs(); + + case SOURCE_DB: + return getSource_db(); + + case SOURCE_TABLE_NAME: + return getSource_table_name(); + + case DEST_DB: + return getDest_db(); + + case DEST_TABLE_NAME: + return getDest_table_name(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case PARTITION_SPECS: + return isSetPartitionSpecs(); + case SOURCE_DB: + return isSetSource_db(); + case SOURCE_TABLE_NAME: + return isSetSource_table_name(); + case DEST_DB: + return isSetDest_db(); + case DEST_TABLE_NAME: + return isSetDest_table_name(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof exchange_partition_args) + return this.equals((exchange_partition_args)that); + return false; + } + + public boolean equals(exchange_partition_args that) { + if (that == null) + return false; + + boolean this_present_partitionSpecs = true && this.isSetPartitionSpecs(); + boolean that_present_partitionSpecs = true && that.isSetPartitionSpecs(); + if (this_present_partitionSpecs || that_present_partitionSpecs) { + if (!(this_present_partitionSpecs && that_present_partitionSpecs)) + return false; + if (!this.partitionSpecs.equals(that.partitionSpecs)) + return false; + } + + boolean this_present_source_db = true && this.isSetSource_db(); + boolean that_present_source_db = true && that.isSetSource_db(); + if (this_present_source_db || that_present_source_db) { + if (!(this_present_source_db && that_present_source_db)) + return false; + if (!this.source_db.equals(that.source_db)) + return false; + } + + boolean this_present_source_table_name = true && this.isSetSource_table_name(); + boolean that_present_source_table_name = true && that.isSetSource_table_name(); + if (this_present_source_table_name || that_present_source_table_name) { + if (!(this_present_source_table_name && that_present_source_table_name)) + return false; + if (!this.source_table_name.equals(that.source_table_name)) + return false; + } + + boolean this_present_dest_db = true && this.isSetDest_db(); + boolean that_present_dest_db = true && that.isSetDest_db(); + if (this_present_dest_db || that_present_dest_db) { + if (!(this_present_dest_db && that_present_dest_db)) + return false; + if (!this.dest_db.equals(that.dest_db)) + return false; + } + + boolean this_present_dest_table_name = true && this.isSetDest_table_name(); + boolean that_present_dest_table_name = true && that.isSetDest_table_name(); + if (this_present_dest_table_name || that_present_dest_table_name) { + if (!(this_present_dest_table_name && that_present_dest_table_name)) + return false; + if (!this.dest_table_name.equals(that.dest_table_name)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_partitionSpecs = true && (isSetPartitionSpecs()); + list.add(present_partitionSpecs); + if (present_partitionSpecs) + list.add(partitionSpecs); + + boolean present_source_db = true && (isSetSource_db()); + list.add(present_source_db); + if (present_source_db) + list.add(source_db); + + boolean present_source_table_name = true && (isSetSource_table_name()); + list.add(present_source_table_name); + if (present_source_table_name) + list.add(source_table_name); + + boolean present_dest_db = true && (isSetDest_db()); + list.add(present_dest_db); + if (present_dest_db) + list.add(dest_db); + + boolean present_dest_table_name = true && (isSetDest_table_name()); + list.add(present_dest_table_name); + if (present_dest_table_name) + list.add(dest_table_name); + + return list.hashCode(); + } + + @Override + public int compareTo(exchange_partition_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPartitionSpecs()).compareTo(other.isSetPartitionSpecs()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartitionSpecs()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partitionSpecs, other.partitionSpecs); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSource_db()).compareTo(other.isSetSource_db()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSource_db()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.source_db, other.source_db); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSource_table_name()).compareTo(other.isSetSource_table_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSource_table_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.source_table_name, other.source_table_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDest_db()).compareTo(other.isSetDest_db()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDest_db()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest_db, other.dest_db); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDest_table_name()).compareTo(other.isSetDest_table_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDest_table_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest_table_name, other.dest_table_name); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("exchange_partition_args("); + boolean first = true; + + sb.append("partitionSpecs:"); + if (this.partitionSpecs == null) { + sb.append("null"); + } else { + sb.append(this.partitionSpecs); + } + first = false; + if (!first) sb.append(", "); + sb.append("source_db:"); + if (this.source_db == null) { + sb.append("null"); + } else { + sb.append(this.source_db); + } + first = false; + if (!first) sb.append(", "); + sb.append("source_table_name:"); + if (this.source_table_name == null) { + sb.append("null"); + } else { + sb.append(this.source_table_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("dest_db:"); + if (this.dest_db == null) { + sb.append("null"); + } else { + sb.append(this.dest_db); + } + first = false; + if (!first) sb.append(", "); + sb.append("dest_table_name:"); + if (this.dest_table_name == null) { + sb.append("null"); + } else { + sb.append(this.dest_table_name); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class exchange_partition_argsStandardSchemeFactory implements SchemeFactory { + public exchange_partition_argsStandardScheme getScheme() { + return new exchange_partition_argsStandardScheme(); + } + } + + private static class exchange_partition_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // PARTITION_SPECS + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map746 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map746.size); + String _key747; + String _val748; + for (int _i749 = 0; _i749 < _map746.size; ++_i749) + { + _key747 = iprot.readString(); + _val748 = iprot.readString(); + struct.partitionSpecs.put(_key747, _val748); + } + iprot.readMapEnd(); + } + struct.setPartitionSpecsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // SOURCE_DB + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.source_db = iprot.readString(); + struct.setSource_dbIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // SOURCE_TABLE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.source_table_name = iprot.readString(); + struct.setSource_table_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DEST_DB + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dest_db = iprot.readString(); + struct.setDest_dbIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // DEST_TABLE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dest_table_name = iprot.readString(); + struct.setDest_table_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.partitionSpecs != null) { + oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); + for (Map.Entry _iter750 : struct.partitionSpecs.entrySet()) + { + oprot.writeString(_iter750.getKey()); + oprot.writeString(_iter750.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.source_db != null) { + oprot.writeFieldBegin(SOURCE_DB_FIELD_DESC); + oprot.writeString(struct.source_db); + oprot.writeFieldEnd(); + } + if (struct.source_table_name != null) { + oprot.writeFieldBegin(SOURCE_TABLE_NAME_FIELD_DESC); + oprot.writeString(struct.source_table_name); + oprot.writeFieldEnd(); + } + if (struct.dest_db != null) { + oprot.writeFieldBegin(DEST_DB_FIELD_DESC); + oprot.writeString(struct.dest_db); + oprot.writeFieldEnd(); + } + if (struct.dest_table_name != null) { + oprot.writeFieldBegin(DEST_TABLE_NAME_FIELD_DESC); + oprot.writeString(struct.dest_table_name); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class exchange_partition_argsTupleSchemeFactory implements SchemeFactory { + public exchange_partition_argsTupleScheme getScheme() { + return new exchange_partition_argsTupleScheme(); + } + } + + private static class exchange_partition_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPartitionSpecs()) { + optionals.set(0); + } + if (struct.isSetSource_db()) { + optionals.set(1); + } + if (struct.isSetSource_table_name()) { + optionals.set(2); + } + if (struct.isSetDest_db()) { + optionals.set(3); + } + if (struct.isSetDest_table_name()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetPartitionSpecs()) { + { + oprot.writeI32(struct.partitionSpecs.size()); + for (Map.Entry _iter751 : struct.partitionSpecs.entrySet()) + { + oprot.writeString(_iter751.getKey()); + oprot.writeString(_iter751.getValue()); + } + } + } + if (struct.isSetSource_db()) { + oprot.writeString(struct.source_db); + } + if (struct.isSetSource_table_name()) { + oprot.writeString(struct.source_table_name); + } + if (struct.isSetDest_db()) { + oprot.writeString(struct.dest_db); + } + if (struct.isSetDest_table_name()) { + oprot.writeString(struct.dest_table_name); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map752 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map752.size); + String _key753; + String _val754; + for (int _i755 = 0; _i755 < _map752.size; ++_i755) + { + _key753 = iprot.readString(); + _val754 = iprot.readString(); + struct.partitionSpecs.put(_key753, _val754); + } + } + struct.setPartitionSpecsIsSet(true); + } + if (incoming.get(1)) { + struct.source_db = iprot.readString(); + struct.setSource_dbIsSet(true); + } + if (incoming.get(2)) { + struct.source_table_name = iprot.readString(); + struct.setSource_table_nameIsSet(true); + } + if (incoming.get(3)) { + struct.dest_db = iprot.readString(); + struct.setDest_dbIsSet(true); + } + if (incoming.get(4)) { + struct.dest_table_name = iprot.readString(); + struct.setDest_table_nameIsSet(true); + } + } + } + + } + + public static class exchange_partition_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partition_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + private static final org.apache.thrift.protocol.TField O4_FIELD_DESC = new org.apache.thrift.protocol.TField("o4", org.apache.thrift.protocol.TType.STRUCT, (short)4); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new exchange_partition_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new exchange_partition_resultTupleSchemeFactory()); + } + + private Partition success; // required + private MetaException o1; // required + private NoSuchObjectException o2; // required + private InvalidObjectException o3; // required + private InvalidInputException o4; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partition_result.class, metaDataMap); + } + + public exchange_partition_result() { + } + + public exchange_partition_result( + Partition success, + MetaException o1, + NoSuchObjectException o2, + InvalidObjectException o3, + InvalidInputException o4) + { + this(); + this.success = success; + this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + this.o4 = o4; + } + + /** + * Performs a deep copy on other. + */ + public exchange_partition_result(exchange_partition_result other) { + if (other.isSetSuccess()) { + this.success = new Partition(other.success); + } + if (other.isSetO1()) { + this.o1 = new MetaException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new NoSuchObjectException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new InvalidObjectException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new InvalidInputException(other.o4); + } + } + + public exchange_partition_result deepCopy() { + return new exchange_partition_result(this); + } + + @Override + public void clear() { + this.success = null; + this.o1 = null; + this.o2 = null; + this.o3 = null; + this.o4 = null; + } + + public Partition getSuccess() { + return this.success; + } + + public void setSuccess(Partition success) { + this.success = success; + } + + public void unsetSuccess() { + this.success = null; + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } + + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public MetaException getO1() { + return this.o1; + } + + public void setO1(MetaException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public NoSuchObjectException getO2() { + return this.o2; + } + + public void setO2(NoSuchObjectException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public InvalidObjectException getO3() { + return this.o3; + } + + public void setO3(InvalidObjectException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public InvalidInputException getO4() { + return this.o4; + } + + public void setO4(InvalidInputException o4) { + this.o4 = o4; + } + + public void unsetO4() { + this.o4 = null; + } + + /** Returns true if field o4 is set (has been assigned a value) and false otherwise */ + public boolean isSetO4() { + return this.o4 != null; + } + + public void setO4IsSet(boolean value) { + if (!value) { + this.o4 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Partition)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((MetaException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((NoSuchObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((InvalidObjectException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((InvalidInputException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + case O1: + return getO1(); + + case O2: + return getO2(); + + case O3: + return getO3(); + + case O4: + return getO4(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof exchange_partition_result) + return this.equals((exchange_partition_result)that); + return false; + } + + public boolean equals(exchange_partition_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + boolean this_present_o4 = true && this.isSetO4(); + boolean that_present_o4 = true && that.isSetO4(); + if (this_present_o4 || that_present_o4) { + if (!(this_present_o4 && that_present_o4)) + return false; + if (!this.o4.equals(that.o4)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + boolean present_o4 = true && (isSetO4()); + list.add(present_o4); + if (present_o4) + list.add(o4); + + return list.hashCode(); + } + + @Override + public int compareTo(exchange_partition_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO4()).compareTo(other.isSetO4()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO4()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o4, other.o4); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("exchange_partition_result("); boolean first = true; sb.append("success:"); @@ -67494,6 +69232,22 @@ public String toString() { sb.append(this.o2); } first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + if (!first) sb.append(", "); + sb.append("o4:"); + if (this.o4 == null) { + sb.append("null"); + } else { + sb.append(this.o4); + } + first = false; sb.append(")"); return sb.toString(); } @@ -67522,15 +69276,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class get_partition_resultStandardSchemeFactory implements SchemeFactory { - public get_partition_resultStandardScheme getScheme() { - return new get_partition_resultStandardScheme(); + private static class exchange_partition_resultStandardSchemeFactory implements SchemeFactory { + public exchange_partition_resultStandardScheme getScheme() { + return new exchange_partition_resultStandardScheme(); } } - private static class get_partition_resultStandardScheme extends StandardScheme { + private static class exchange_partition_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -67567,6 +69321,24 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_resul org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new InvalidObjectException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // O4 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o4 = new InvalidInputException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -67576,7 +69348,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_resul struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -67595,22 +69367,32 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_resu struct.o2.write(oprot); oprot.writeFieldEnd(); } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o4 != null) { + oprot.writeFieldBegin(O4_FIELD_DESC); + struct.o4.write(oprot); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class get_partition_resultTupleSchemeFactory implements SchemeFactory { - public get_partition_resultTupleScheme getScheme() { - return new get_partition_resultTupleScheme(); + private static class exchange_partition_resultTupleSchemeFactory implements SchemeFactory { + public exchange_partition_resultTupleScheme getScheme() { + return new exchange_partition_resultTupleScheme(); } } - private static class get_partition_resultTupleScheme extends TupleScheme { + private static class exchange_partition_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -67622,7 +69404,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_resul if (struct.isSetO2()) { optionals.set(2); } - oprot.writeBitSet(optionals, 3); + if (struct.isSetO3()) { + optionals.set(3); + } + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { struct.success.write(oprot); } @@ -67632,12 +69420,18 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_resul if (struct.isSetO2()) { struct.o2.write(oprot); } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + if (struct.isSetO4()) { + struct.o4.write(oprot); + } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { struct.success = new Partition(); struct.success.read(iprot); @@ -67653,13 +69447,23 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_result struct.o2.read(iprot); struct.setO2IsSet(true); } + if (incoming.get(3)) { + struct.o3 = new InvalidObjectException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + if (incoming.get(4)) { + struct.o4 = new InvalidInputException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } } } } - public static class exchange_partition_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partition_args"); + public static class exchange_partitions_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partitions_args"); private static final org.apache.thrift.protocol.TField PARTITION_SPECS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionSpecs", org.apache.thrift.protocol.TType.MAP, (short)1); private static final org.apache.thrift.protocol.TField SOURCE_DB_FIELD_DESC = new org.apache.thrift.protocol.TField("source_db", org.apache.thrift.protocol.TType.STRING, (short)2); @@ -67669,8 +69473,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_result private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new exchange_partition_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new exchange_partition_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new exchange_partitions_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new exchange_partitions_argsTupleSchemeFactory()); } private Map partitionSpecs; // required @@ -67766,13 +69570,13 @@ public String getFieldName() { tmpMap.put(_Fields.DEST_TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("dest_table_name", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partition_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partitions_args.class, metaDataMap); } - public exchange_partition_args() { + public exchange_partitions_args() { } - public exchange_partition_args( + public exchange_partitions_args( Map partitionSpecs, String source_db, String source_table_name, @@ -67790,7 +69594,7 @@ public exchange_partition_args( /** * Performs a deep copy on other. */ - public exchange_partition_args(exchange_partition_args other) { + public exchange_partitions_args(exchange_partitions_args other) { if (other.isSetPartitionSpecs()) { Map __this__partitionSpecs = new HashMap(other.partitionSpecs); this.partitionSpecs = __this__partitionSpecs; @@ -67809,8 +69613,8 @@ public exchange_partition_args(exchange_partition_args other) { } } - public exchange_partition_args deepCopy() { - return new exchange_partition_args(this); + public exchange_partitions_args deepCopy() { + return new exchange_partitions_args(this); } @Override @@ -68039,12 +69843,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof exchange_partition_args) - return this.equals((exchange_partition_args)that); + if (that instanceof exchange_partitions_args) + return this.equals((exchange_partitions_args)that); return false; } - public boolean equals(exchange_partition_args that) { + public boolean equals(exchange_partitions_args that) { if (that == null) return false; @@ -68129,7 +69933,7 @@ public int hashCode() { } @Override - public int compareTo(exchange_partition_args other) { + public int compareTo(exchange_partitions_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -68203,7 +70007,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("exchange_partition_args("); + StringBuilder sb = new StringBuilder("exchange_partitions_args("); boolean first = true; sb.append("partitionSpecs:"); @@ -68270,15 +70074,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class exchange_partition_argsStandardSchemeFactory implements SchemeFactory { - public exchange_partition_argsStandardScheme getScheme() { - return new exchange_partition_argsStandardScheme(); + private static class exchange_partitions_argsStandardSchemeFactory implements SchemeFactory { + public exchange_partitions_argsStandardScheme getScheme() { + return new exchange_partitions_argsStandardScheme(); } } - private static class exchange_partition_argsStandardScheme extends StandardScheme { + private static class exchange_partitions_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -68291,15 +70095,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ case 1: // PARTITION_SPECS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map746 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map746.size); - String _key747; - String _val748; - for (int _i749 = 0; _i749 < _map746.size; ++_i749) + org.apache.thrift.protocol.TMap _map756 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map756.size); + String _key757; + String _val758; + for (int _i759 = 0; _i759 < _map756.size; ++_i759) { - _key747 = iprot.readString(); - _val748 = iprot.readString(); - struct.partitionSpecs.put(_key747, _val748); + _key757 = iprot.readString(); + _val758 = iprot.readString(); + struct.partitionSpecs.put(_key757, _val758); } iprot.readMapEnd(); } @@ -68349,7 +70153,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partitions_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -68357,10 +70161,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition oprot.writeFieldBegin(PARTITION_SPECS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.partitionSpecs.size())); - for (Map.Entry _iter750 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter760 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter750.getKey()); - oprot.writeString(_iter750.getValue()); + oprot.writeString(_iter760.getKey()); + oprot.writeString(_iter760.getValue()); } oprot.writeMapEnd(); } @@ -68392,16 +70196,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition } - private static class exchange_partition_argsTupleSchemeFactory implements SchemeFactory { - public exchange_partition_argsTupleScheme getScheme() { - return new exchange_partition_argsTupleScheme(); + private static class exchange_partitions_argsTupleSchemeFactory implements SchemeFactory { + public exchange_partitions_argsTupleScheme getScheme() { + return new exchange_partitions_argsTupleScheme(); } } - private static class exchange_partition_argsTupleScheme extends TupleScheme { + private static class exchange_partitions_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetPartitionSpecs()) { @@ -68423,10 +70227,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter751 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter761 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter751.getKey()); - oprot.writeString(_iter751.getValue()); + oprot.writeString(_iter761.getKey()); + oprot.writeString(_iter761.getValue()); } } } @@ -68445,20 +70249,20 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map752 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.partitionSpecs = new HashMap(2*_map752.size); - String _key753; - String _val754; - for (int _i755 = 0; _i755 < _map752.size; ++_i755) + org.apache.thrift.protocol.TMap _map762 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.partitionSpecs = new HashMap(2*_map762.size); + String _key763; + String _val764; + for (int _i765 = 0; _i765 < _map762.size; ++_i765) { - _key753 = iprot.readString(); - _val754 = iprot.readString(); - struct.partitionSpecs.put(_key753, _val754); + _key763 = iprot.readString(); + _val764 = iprot.readString(); + struct.partitionSpecs.put(_key763, _val764); } } struct.setPartitionSpecsIsSet(true); @@ -68484,10 +70288,10 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a } - public static class exchange_partition_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partition_result"); + public static class exchange_partitions_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("exchange_partitions_result"); - private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0); + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); @@ -68495,11 +70299,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new exchange_partition_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new exchange_partition_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new exchange_partitions_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new exchange_partitions_resultTupleSchemeFactory()); } - private Partition success; // required + private List success; // required private MetaException o1; // required private NoSuchObjectException o2; // required private InvalidObjectException o3; // required @@ -68580,7 +70384,8 @@ public String getFieldName() { static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class))); + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class)))); tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, @@ -68590,14 +70395,14 @@ public String getFieldName() { tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partition_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(exchange_partitions_result.class, metaDataMap); } - public exchange_partition_result() { + public exchange_partitions_result() { } - public exchange_partition_result( - Partition success, + public exchange_partitions_result( + List success, MetaException o1, NoSuchObjectException o2, InvalidObjectException o3, @@ -68614,9 +70419,13 @@ public exchange_partition_result( /** * Performs a deep copy on other. */ - public exchange_partition_result(exchange_partition_result other) { + public exchange_partitions_result(exchange_partitions_result other) { if (other.isSetSuccess()) { - this.success = new Partition(other.success); + List __this__success = new ArrayList(other.success.size()); + for (Partition other_element : other.success) { + __this__success.add(new Partition(other_element)); + } + this.success = __this__success; } if (other.isSetO1()) { this.o1 = new MetaException(other.o1); @@ -68632,8 +70441,8 @@ public exchange_partition_result(exchange_partition_result other) { } } - public exchange_partition_result deepCopy() { - return new exchange_partition_result(this); + public exchange_partitions_result deepCopy() { + return new exchange_partitions_result(this); } @Override @@ -68645,11 +70454,26 @@ public void clear() { this.o4 = null; } - public Partition getSuccess() { + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(Partition elem) { + if (this.success == null) { + this.success = new ArrayList(); + } + this.success.add(elem); + } + + public List getSuccess() { return this.success; } - public void setSuccess(Partition success) { + public void setSuccess(List success) { this.success = success; } @@ -68766,7 +70590,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetSuccess(); } else { - setSuccess((Partition)value); + setSuccess((List)value); } break; @@ -68851,12 +70675,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof exchange_partition_result) - return this.equals((exchange_partition_result)that); + if (that instanceof exchange_partitions_result) + return this.equals((exchange_partitions_result)that); return false; } - public boolean equals(exchange_partition_result that) { + public boolean equals(exchange_partitions_result that) { if (that == null) return false; @@ -68941,7 +70765,7 @@ public int hashCode() { } @Override - public int compareTo(exchange_partition_result other) { + public int compareTo(exchange_partitions_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -69015,7 +70839,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("exchange_partition_result("); + StringBuilder sb = new StringBuilder("exchange_partitions_result("); boolean first = true; sb.append("success:"); @@ -69064,9 +70888,6 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (success != null) { - success.validate(); - } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -69085,15 +70906,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class exchange_partition_resultStandardSchemeFactory implements SchemeFactory { - public exchange_partition_resultStandardScheme getScheme() { - return new exchange_partition_resultStandardScheme(); + private static class exchange_partitions_resultStandardSchemeFactory implements SchemeFactory { + public exchange_partitions_resultStandardScheme getScheme() { + return new exchange_partitions_resultStandardScheme(); } } - private static class exchange_partition_resultStandardScheme extends StandardScheme { + private static class exchange_partitions_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partitions_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -69104,9 +70925,19 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ } switch (schemeField.id) { case 0: // SUCCESS - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.success = new Partition(); - struct.success.read(iprot); + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list766 = iprot.readListBegin(); + struct.success = new ArrayList(_list766.size); + Partition _elem767; + for (int _i768 = 0; _i768 < _list766.size; ++_i768) + { + _elem767 = new Partition(); + _elem767.read(iprot); + struct.success.add(_elem767); + } + iprot.readListEnd(); + } struct.setSuccessIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); @@ -69157,13 +70988,20 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, exchange_partition_ struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partitions_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); if (struct.success != null) { oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - struct.success.write(oprot); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); + for (Partition _iter769 : struct.success) + { + _iter769.write(oprot); + } + oprot.writeListEnd(); + } oprot.writeFieldEnd(); } if (struct.o1 != null) { @@ -69192,16 +71030,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, exchange_partition } - private static class exchange_partition_resultTupleSchemeFactory implements SchemeFactory { - public exchange_partition_resultTupleScheme getScheme() { - return new exchange_partition_resultTupleScheme(); + private static class exchange_partitions_resultTupleSchemeFactory implements SchemeFactory { + public exchange_partitions_resultTupleScheme getScheme() { + return new exchange_partitions_resultTupleScheme(); } } - private static class exchange_partition_resultTupleScheme extends TupleScheme { + private static class exchange_partitions_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -69221,7 +71059,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ } oprot.writeBitSet(optionals, 5); if (struct.isSetSuccess()) { - struct.success.write(oprot); + { + oprot.writeI32(struct.success.size()); + for (Partition _iter770 : struct.success) + { + _iter770.write(oprot); + } + } } if (struct.isSetO1()) { struct.o1.write(oprot); @@ -69238,12 +71082,21 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partitions_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { - struct.success = new Partition(); - struct.success.read(iprot); + { + org.apache.thrift.protocol.TList _list771 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list771.size); + Partition _elem772; + for (int _i773 = 0; _i773 < _list771.size; ++_i773) + { + _elem772 = new Partition(); + _elem772.read(iprot); + struct.success.add(_elem772); + } + } struct.setSuccessIsSet(true); } if (incoming.get(1)) { @@ -69940,13 +71793,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list756 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list756.size); - String _elem757; - for (int _i758 = 0; _i758 < _list756.size; ++_i758) + org.apache.thrift.protocol.TList _list774 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list774.size); + String _elem775; + for (int _i776 = 0; _i776 < _list774.size; ++_i776) { - _elem757 = iprot.readString(); - struct.part_vals.add(_elem757); + _elem775 = iprot.readString(); + struct.part_vals.add(_elem775); } iprot.readListEnd(); } @@ -69966,13 +71819,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_with_ case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list759 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list759.size); - String _elem760; - for (int _i761 = 0; _i761 < _list759.size; ++_i761) + org.apache.thrift.protocol.TList _list777 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list777.size); + String _elem778; + for (int _i779 = 0; _i779 < _list777.size; ++_i779) { - _elem760 = iprot.readString(); - struct.group_names.add(_elem760); + _elem778 = iprot.readString(); + struct.group_names.add(_elem778); } iprot.readListEnd(); } @@ -70008,9 +71861,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter762 : struct.part_vals) + for (String _iter780 : struct.part_vals) { - oprot.writeString(_iter762); + oprot.writeString(_iter780); } oprot.writeListEnd(); } @@ -70025,9 +71878,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_with oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter763 : struct.group_names) + for (String _iter781 : struct.group_names) { - oprot.writeString(_iter763); + oprot.writeString(_iter781); } oprot.writeListEnd(); } @@ -70076,9 +71929,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter764 : struct.part_vals) + for (String _iter782 : struct.part_vals) { - oprot.writeString(_iter764); + oprot.writeString(_iter782); } } } @@ -70088,9 +71941,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_with_ if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter765 : struct.group_names) + for (String _iter783 : struct.group_names) { - oprot.writeString(_iter765); + oprot.writeString(_iter783); } } } @@ -70110,13 +71963,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list766 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list766.size); - String _elem767; - for (int _i768 = 0; _i768 < _list766.size; ++_i768) + org.apache.thrift.protocol.TList _list784 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list784.size); + String _elem785; + for (int _i786 = 0; _i786 < _list784.size; ++_i786) { - _elem767 = iprot.readString(); - struct.part_vals.add(_elem767); + _elem785 = iprot.readString(); + struct.part_vals.add(_elem785); } } struct.setPart_valsIsSet(true); @@ -70127,13 +71980,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list769 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list769.size); - String _elem770; - for (int _i771 = 0; _i771 < _list769.size; ++_i771) + org.apache.thrift.protocol.TList _list787 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list787.size); + String _elem788; + for (int _i789 = 0; _i789 < _list787.size; ++_i789) { - _elem770 = iprot.readString(); - struct.group_names.add(_elem770); + _elem788 = iprot.readString(); + struct.group_names.add(_elem788); } } struct.setGroup_namesIsSet(true); @@ -72902,14 +74755,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list772 = iprot.readListBegin(); - struct.success = new ArrayList(_list772.size); - Partition _elem773; - for (int _i774 = 0; _i774 < _list772.size; ++_i774) + org.apache.thrift.protocol.TList _list790 = iprot.readListBegin(); + struct.success = new ArrayList(_list790.size); + Partition _elem791; + for (int _i792 = 0; _i792 < _list790.size; ++_i792) { - _elem773 = new Partition(); - _elem773.read(iprot); - struct.success.add(_elem773); + _elem791 = new Partition(); + _elem791.read(iprot); + struct.success.add(_elem791); } iprot.readListEnd(); } @@ -72953,9 +74806,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter775 : struct.success) + for (Partition _iter793 : struct.success) { - _iter775.write(oprot); + _iter793.write(oprot); } oprot.writeListEnd(); } @@ -73002,9 +74855,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter776 : struct.success) + for (Partition _iter794 : struct.success) { - _iter776.write(oprot); + _iter794.write(oprot); } } } @@ -73022,14 +74875,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_resul BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list777 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list777.size); - Partition _elem778; - for (int _i779 = 0; _i779 < _list777.size; ++_i779) + org.apache.thrift.protocol.TList _list795 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list795.size); + Partition _elem796; + for (int _i797 = 0; _i797 < _list795.size; ++_i797) { - _elem778 = new Partition(); - _elem778.read(iprot); - struct.success.add(_elem778); + _elem796 = new Partition(); + _elem796.read(iprot); + struct.success.add(_elem796); } } struct.setSuccessIsSet(true); @@ -73719,13 +75572,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 5: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list780 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list780.size); - String _elem781; - for (int _i782 = 0; _i782 < _list780.size; ++_i782) + org.apache.thrift.protocol.TList _list798 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list798.size); + String _elem799; + for (int _i800 = 0; _i800 < _list798.size; ++_i800) { - _elem781 = iprot.readString(); - struct.group_names.add(_elem781); + _elem799 = iprot.readString(); + struct.group_names.add(_elem799); } iprot.readListEnd(); } @@ -73769,9 +75622,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter783 : struct.group_names) + for (String _iter801 : struct.group_names) { - oprot.writeString(_iter783); + oprot.writeString(_iter801); } oprot.writeListEnd(); } @@ -73826,9 +75679,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter784 : struct.group_names) + for (String _iter802 : struct.group_names) { - oprot.writeString(_iter784); + oprot.writeString(_iter802); } } } @@ -73856,13 +75709,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list785.size); - String _elem786; - for (int _i787 = 0; _i787 < _list785.size; ++_i787) + org.apache.thrift.protocol.TList _list803 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list803.size); + String _elem804; + for (int _i805 = 0; _i805 < _list803.size; ++_i805) { - _elem786 = iprot.readString(); - struct.group_names.add(_elem786); + _elem804 = iprot.readString(); + struct.group_names.add(_elem804); } } struct.setGroup_namesIsSet(true); @@ -74349,14 +76202,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_with case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list788 = iprot.readListBegin(); - struct.success = new ArrayList(_list788.size); - Partition _elem789; - for (int _i790 = 0; _i790 < _list788.size; ++_i790) + org.apache.thrift.protocol.TList _list806 = iprot.readListBegin(); + struct.success = new ArrayList(_list806.size); + Partition _elem807; + for (int _i808 = 0; _i808 < _list806.size; ++_i808) { - _elem789 = new Partition(); - _elem789.read(iprot); - struct.success.add(_elem789); + _elem807 = new Partition(); + _elem807.read(iprot); + struct.success.add(_elem807); } iprot.readListEnd(); } @@ -74400,9 +76253,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_wit oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter791 : struct.success) + for (Partition _iter809 : struct.success) { - _iter791.write(oprot); + _iter809.write(oprot); } oprot.writeListEnd(); } @@ -74449,9 +76302,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter792 : struct.success) + for (Partition _iter810 : struct.success) { - _iter792.write(oprot); + _iter810.write(oprot); } } } @@ -74469,14 +76322,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list793.size); - Partition _elem794; - for (int _i795 = 0; _i795 < _list793.size; ++_i795) + org.apache.thrift.protocol.TList _list811 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list811.size); + Partition _elem812; + for (int _i813 = 0; _i813 < _list811.size; ++_i813) { - _elem794 = new Partition(); - _elem794.read(iprot); - struct.success.add(_elem794); + _elem812 = new Partition(); + _elem812.read(iprot); + struct.success.add(_elem812); } } struct.setSuccessIsSet(true); @@ -75539,14 +77392,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_pspe case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list796 = iprot.readListBegin(); - struct.success = new ArrayList(_list796.size); - PartitionSpec _elem797; - for (int _i798 = 0; _i798 < _list796.size; ++_i798) + org.apache.thrift.protocol.TList _list814 = iprot.readListBegin(); + struct.success = new ArrayList(_list814.size); + PartitionSpec _elem815; + for (int _i816 = 0; _i816 < _list814.size; ++_i816) { - _elem797 = new PartitionSpec(); - _elem797.read(iprot); - struct.success.add(_elem797); + _elem815 = new PartitionSpec(); + _elem815.read(iprot); + struct.success.add(_elem815); } iprot.readListEnd(); } @@ -75590,9 +77443,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_psp oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter799 : struct.success) + for (PartitionSpec _iter817 : struct.success) { - _iter799.write(oprot); + _iter817.write(oprot); } oprot.writeListEnd(); } @@ -75639,9 +77492,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspe if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter800 : struct.success) + for (PartitionSpec _iter818 : struct.success) { - _iter800.write(oprot); + _iter818.write(oprot); } } } @@ -75659,14 +77512,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_pspec BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list801.size); - PartitionSpec _elem802; - for (int _i803 = 0; _i803 < _list801.size; ++_i803) + org.apache.thrift.protocol.TList _list819 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list819.size); + PartitionSpec _elem820; + for (int _i821 = 0; _i821 < _list819.size; ++_i821) { - _elem802 = new PartitionSpec(); - _elem802.read(iprot); - struct.success.add(_elem802); + _elem820 = new PartitionSpec(); + _elem820.read(iprot); + struct.success.add(_elem820); } } struct.setSuccessIsSet(true); @@ -76645,13 +78498,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list804 = iprot.readListBegin(); - struct.success = new ArrayList(_list804.size); - String _elem805; - for (int _i806 = 0; _i806 < _list804.size; ++_i806) + org.apache.thrift.protocol.TList _list822 = iprot.readListBegin(); + struct.success = new ArrayList(_list822.size); + String _elem823; + for (int _i824 = 0; _i824 < _list822.size; ++_i824) { - _elem805 = iprot.readString(); - struct.success.add(_elem805); + _elem823 = iprot.readString(); + struct.success.add(_elem823); } iprot.readListEnd(); } @@ -76686,9 +78539,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter807 : struct.success) + for (String _iter825 : struct.success) { - oprot.writeString(_iter807); + oprot.writeString(_iter825); } oprot.writeListEnd(); } @@ -76727,9 +78580,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter808 : struct.success) + for (String _iter826 : struct.success) { - oprot.writeString(_iter808); + oprot.writeString(_iter826); } } } @@ -76744,13 +78597,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list809 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list809.size); - String _elem810; - for (int _i811 = 0; _i811 < _list809.size; ++_i811) + org.apache.thrift.protocol.TList _list827 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list827.size); + String _elem828; + for (int _i829 = 0; _i829 < _list827.size; ++_i829) { - _elem810 = iprot.readString(); - struct.success.add(_elem810); + _elem828 = iprot.readString(); + struct.success.add(_elem828); } } struct.setSuccessIsSet(true); @@ -77338,13 +79191,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_a case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list812 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list812.size); - String _elem813; - for (int _i814 = 0; _i814 < _list812.size; ++_i814) + org.apache.thrift.protocol.TList _list830 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list830.size); + String _elem831; + for (int _i832 = 0; _i832 < _list830.size; ++_i832) { - _elem813 = iprot.readString(); - struct.part_vals.add(_elem813); + _elem831 = iprot.readString(); + struct.part_vals.add(_elem831); } iprot.readListEnd(); } @@ -77388,9 +79241,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter815 : struct.part_vals) + for (String _iter833 : struct.part_vals) { - oprot.writeString(_iter815); + oprot.writeString(_iter833); } oprot.writeListEnd(); } @@ -77439,9 +79292,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_a if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter816 : struct.part_vals) + for (String _iter834 : struct.part_vals) { - oprot.writeString(_iter816); + oprot.writeString(_iter834); } } } @@ -77464,13 +79317,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list817 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list817.size); - String _elem818; - for (int _i819 = 0; _i819 < _list817.size; ++_i819) + org.apache.thrift.protocol.TList _list835 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list835.size); + String _elem836; + for (int _i837 = 0; _i837 < _list835.size; ++_i837) { - _elem818 = iprot.readString(); - struct.part_vals.add(_elem818); + _elem836 = iprot.readString(); + struct.part_vals.add(_elem836); } } struct.setPart_valsIsSet(true); @@ -77961,14 +79814,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_r case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list820 = iprot.readListBegin(); - struct.success = new ArrayList(_list820.size); - Partition _elem821; - for (int _i822 = 0; _i822 < _list820.size; ++_i822) + org.apache.thrift.protocol.TList _list838 = iprot.readListBegin(); + struct.success = new ArrayList(_list838.size); + Partition _elem839; + for (int _i840 = 0; _i840 < _list838.size; ++_i840) { - _elem821 = new Partition(); - _elem821.read(iprot); - struct.success.add(_elem821); + _elem839 = new Partition(); + _elem839.read(iprot); + struct.success.add(_elem839); } iprot.readListEnd(); } @@ -78012,9 +79865,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter823 : struct.success) + for (Partition _iter841 : struct.success) { - _iter823.write(oprot); + _iter841.write(oprot); } oprot.writeListEnd(); } @@ -78061,9 +79914,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter824 : struct.success) + for (Partition _iter842 : struct.success) { - _iter824.write(oprot); + _iter842.write(oprot); } } } @@ -78081,14 +79934,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_re BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list825.size); - Partition _elem826; - for (int _i827 = 0; _i827 < _list825.size; ++_i827) + org.apache.thrift.protocol.TList _list843 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list843.size); + Partition _elem844; + for (int _i845 = 0; _i845 < _list843.size; ++_i845) { - _elem826 = new Partition(); - _elem826.read(iprot); - struct.success.add(_elem826); + _elem844 = new Partition(); + _elem844.read(iprot); + struct.success.add(_elem844); } } struct.setSuccessIsSet(true); @@ -78860,13 +80713,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list828 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list828.size); - String _elem829; - for (int _i830 = 0; _i830 < _list828.size; ++_i830) + org.apache.thrift.protocol.TList _list846 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list846.size); + String _elem847; + for (int _i848 = 0; _i848 < _list846.size; ++_i848) { - _elem829 = iprot.readString(); - struct.part_vals.add(_elem829); + _elem847 = iprot.readString(); + struct.part_vals.add(_elem847); } iprot.readListEnd(); } @@ -78894,13 +80747,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 6: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list831 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list831.size); - String _elem832; - for (int _i833 = 0; _i833 < _list831.size; ++_i833) + org.apache.thrift.protocol.TList _list849 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list849.size); + String _elem850; + for (int _i851 = 0; _i851 < _list849.size; ++_i851) { - _elem832 = iprot.readString(); - struct.group_names.add(_elem832); + _elem850 = iprot.readString(); + struct.group_names.add(_elem850); } iprot.readListEnd(); } @@ -78936,9 +80789,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter834 : struct.part_vals) + for (String _iter852 : struct.part_vals) { - oprot.writeString(_iter834); + oprot.writeString(_iter852); } oprot.writeListEnd(); } @@ -78956,9 +80809,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter835 : struct.group_names) + for (String _iter853 : struct.group_names) { - oprot.writeString(_iter835); + oprot.writeString(_iter853); } oprot.writeListEnd(); } @@ -79010,9 +80863,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter836 : struct.part_vals) + for (String _iter854 : struct.part_vals) { - oprot.writeString(_iter836); + oprot.writeString(_iter854); } } } @@ -79025,9 +80878,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter837 : struct.group_names) + for (String _iter855 : struct.group_names) { - oprot.writeString(_iter837); + oprot.writeString(_iter855); } } } @@ -79047,13 +80900,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list838 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list838.size); - String _elem839; - for (int _i840 = 0; _i840 < _list838.size; ++_i840) + org.apache.thrift.protocol.TList _list856 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list856.size); + String _elem857; + for (int _i858 = 0; _i858 < _list856.size; ++_i858) { - _elem839 = iprot.readString(); - struct.part_vals.add(_elem839); + _elem857 = iprot.readString(); + struct.part_vals.add(_elem857); } } struct.setPart_valsIsSet(true); @@ -79068,13 +80921,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list841.size); - String _elem842; - for (int _i843 = 0; _i843 < _list841.size; ++_i843) + org.apache.thrift.protocol.TList _list859 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list859.size); + String _elem860; + for (int _i861 = 0; _i861 < _list859.size; ++_i861) { - _elem842 = iprot.readString(); - struct.group_names.add(_elem842); + _elem860 = iprot.readString(); + struct.group_names.add(_elem860); } } struct.setGroup_namesIsSet(true); @@ -79561,14 +81414,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_ps_w case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); - struct.success = new ArrayList(_list844.size); - Partition _elem845; - for (int _i846 = 0; _i846 < _list844.size; ++_i846) + org.apache.thrift.protocol.TList _list862 = iprot.readListBegin(); + struct.success = new ArrayList(_list862.size); + Partition _elem863; + for (int _i864 = 0; _i864 < _list862.size; ++_i864) { - _elem845 = new Partition(); - _elem845.read(iprot); - struct.success.add(_elem845); + _elem863 = new Partition(); + _elem863.read(iprot); + struct.success.add(_elem863); } iprot.readListEnd(); } @@ -79612,9 +81465,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_ps_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter847 : struct.success) + for (Partition _iter865 : struct.success) { - _iter847.write(oprot); + _iter865.write(oprot); } oprot.writeListEnd(); } @@ -79661,9 +81514,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter848 : struct.success) + for (Partition _iter866 : struct.success) { - _iter848.write(oprot); + _iter866.write(oprot); } } } @@ -79681,14 +81534,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list849 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list849.size); - Partition _elem850; - for (int _i851 = 0; _i851 < _list849.size; ++_i851) + org.apache.thrift.protocol.TList _list867 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list867.size); + Partition _elem868; + for (int _i869 = 0; _i869 < _list867.size; ++_i869) { - _elem850 = new Partition(); - _elem850.read(iprot); - struct.success.add(_elem850); + _elem868 = new Partition(); + _elem868.read(iprot); + struct.success.add(_elem868); } } struct.setSuccessIsSet(true); @@ -80281,13 +82134,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list852.size); - String _elem853; - for (int _i854 = 0; _i854 < _list852.size; ++_i854) + org.apache.thrift.protocol.TList _list870 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list870.size); + String _elem871; + for (int _i872 = 0; _i872 < _list870.size; ++_i872) { - _elem853 = iprot.readString(); - struct.part_vals.add(_elem853); + _elem871 = iprot.readString(); + struct.part_vals.add(_elem871); } iprot.readListEnd(); } @@ -80331,9 +82184,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter855 : struct.part_vals) + for (String _iter873 : struct.part_vals) { - oprot.writeString(_iter855); + oprot.writeString(_iter873); } oprot.writeListEnd(); } @@ -80382,9 +82235,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter856 : struct.part_vals) + for (String _iter874 : struct.part_vals) { - oprot.writeString(_iter856); + oprot.writeString(_iter874); } } } @@ -80407,13 +82260,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list857.size); - String _elem858; - for (int _i859 = 0; _i859 < _list857.size; ++_i859) + org.apache.thrift.protocol.TList _list875 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list875.size); + String _elem876; + for (int _i877 = 0; _i877 < _list875.size; ++_i877) { - _elem858 = iprot.readString(); - struct.part_vals.add(_elem858); + _elem876 = iprot.readString(); + struct.part_vals.add(_elem876); } } struct.setPart_valsIsSet(true); @@ -80901,13 +82754,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_names case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); - struct.success = new ArrayList(_list860.size); - String _elem861; - for (int _i862 = 0; _i862 < _list860.size; ++_i862) + org.apache.thrift.protocol.TList _list878 = iprot.readListBegin(); + struct.success = new ArrayList(_list878.size); + String _elem879; + for (int _i880 = 0; _i880 < _list878.size; ++_i880) { - _elem861 = iprot.readString(); - struct.success.add(_elem861); + _elem879 = iprot.readString(); + struct.success.add(_elem879); } iprot.readListEnd(); } @@ -80951,9 +82804,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_name oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter863 : struct.success) + for (String _iter881 : struct.success) { - oprot.writeString(_iter863); + oprot.writeString(_iter881); } oprot.writeListEnd(); } @@ -81000,9 +82853,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter864 : struct.success) + for (String _iter882 : struct.success) { - oprot.writeString(_iter864); + oprot.writeString(_iter882); } } } @@ -81020,13 +82873,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list865.size); - String _elem866; - for (int _i867 = 0; _i867 < _list865.size; ++_i867) + org.apache.thrift.protocol.TList _list883 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list883.size); + String _elem884; + for (int _i885 = 0; _i885 < _list883.size; ++_i885) { - _elem866 = iprot.readString(); - struct.success.add(_elem866); + _elem884 = iprot.readString(); + struct.success.add(_elem884); } } struct.setSuccessIsSet(true); @@ -82193,14 +84046,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list868 = iprot.readListBegin(); - struct.success = new ArrayList(_list868.size); - Partition _elem869; - for (int _i870 = 0; _i870 < _list868.size; ++_i870) + org.apache.thrift.protocol.TList _list886 = iprot.readListBegin(); + struct.success = new ArrayList(_list886.size); + Partition _elem887; + for (int _i888 = 0; _i888 < _list886.size; ++_i888) { - _elem869 = new Partition(); - _elem869.read(iprot); - struct.success.add(_elem869); + _elem887 = new Partition(); + _elem887.read(iprot); + struct.success.add(_elem887); } iprot.readListEnd(); } @@ -82244,9 +84097,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter871 : struct.success) + for (Partition _iter889 : struct.success) { - _iter871.write(oprot); + _iter889.write(oprot); } oprot.writeListEnd(); } @@ -82293,9 +84146,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter872 : struct.success) + for (Partition _iter890 : struct.success) { - _iter872.write(oprot); + _iter890.write(oprot); } } } @@ -82313,14 +84166,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list873 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list873.size); - Partition _elem874; - for (int _i875 = 0; _i875 < _list873.size; ++_i875) + org.apache.thrift.protocol.TList _list891 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list891.size); + Partition _elem892; + for (int _i893 = 0; _i893 < _list891.size; ++_i893) { - _elem874 = new Partition(); - _elem874.read(iprot); - struct.success.add(_elem874); + _elem892 = new Partition(); + _elem892.read(iprot); + struct.success.add(_elem892); } } struct.setSuccessIsSet(true); @@ -83487,14 +85340,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_part_specs_by_f case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list876 = iprot.readListBegin(); - struct.success = new ArrayList(_list876.size); - PartitionSpec _elem877; - for (int _i878 = 0; _i878 < _list876.size; ++_i878) + org.apache.thrift.protocol.TList _list894 = iprot.readListBegin(); + struct.success = new ArrayList(_list894.size); + PartitionSpec _elem895; + for (int _i896 = 0; _i896 < _list894.size; ++_i896) { - _elem877 = new PartitionSpec(); - _elem877.read(iprot); - struct.success.add(_elem877); + _elem895 = new PartitionSpec(); + _elem895.read(iprot); + struct.success.add(_elem895); } iprot.readListEnd(); } @@ -83538,9 +85391,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_part_specs_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (PartitionSpec _iter879 : struct.success) + for (PartitionSpec _iter897 : struct.success) { - _iter879.write(oprot); + _iter897.write(oprot); } oprot.writeListEnd(); } @@ -83587,9 +85440,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (PartitionSpec _iter880 : struct.success) + for (PartitionSpec _iter898 : struct.success) { - _iter880.write(oprot); + _iter898.write(oprot); } } } @@ -83607,14 +85460,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_part_specs_by_fi BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list881 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list881.size); - PartitionSpec _elem882; - for (int _i883 = 0; _i883 < _list881.size; ++_i883) + org.apache.thrift.protocol.TList _list899 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list899.size); + PartitionSpec _elem900; + for (int _i901 = 0; _i901 < _list899.size; ++_i901) { - _elem882 = new PartitionSpec(); - _elem882.read(iprot); - struct.success.add(_elem882); + _elem900 = new PartitionSpec(); + _elem900.read(iprot); + struct.success.add(_elem900); } } struct.setSuccessIsSet(true); @@ -85062,13 +86915,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 3: // NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list884 = iprot.readListBegin(); - struct.names = new ArrayList(_list884.size); - String _elem885; - for (int _i886 = 0; _i886 < _list884.size; ++_i886) + org.apache.thrift.protocol.TList _list902 = iprot.readListBegin(); + struct.names = new ArrayList(_list902.size); + String _elem903; + for (int _i904 = 0; _i904 < _list902.size; ++_i904) { - _elem885 = iprot.readString(); - struct.names.add(_elem885); + _elem903 = iprot.readString(); + struct.names.add(_elem903); } iprot.readListEnd(); } @@ -85104,9 +86957,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.names.size())); - for (String _iter887 : struct.names) + for (String _iter905 : struct.names) { - oprot.writeString(_iter887); + oprot.writeString(_iter905); } oprot.writeListEnd(); } @@ -85149,9 +87002,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (String _iter888 : struct.names) + for (String _iter906 : struct.names) { - oprot.writeString(_iter888); + oprot.writeString(_iter906); } } } @@ -85171,13 +87024,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list889 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.names = new ArrayList(_list889.size); - String _elem890; - for (int _i891 = 0; _i891 < _list889.size; ++_i891) + org.apache.thrift.protocol.TList _list907 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.names = new ArrayList(_list907.size); + String _elem908; + for (int _i909 = 0; _i909 < _list907.size; ++_i909) { - _elem890 = iprot.readString(); - struct.names.add(_elem890); + _elem908 = iprot.readString(); + struct.names.add(_elem908); } } struct.setNamesIsSet(true); @@ -85664,14 +87517,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partitions_by_n case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list892 = iprot.readListBegin(); - struct.success = new ArrayList(_list892.size); - Partition _elem893; - for (int _i894 = 0; _i894 < _list892.size; ++_i894) + org.apache.thrift.protocol.TList _list910 = iprot.readListBegin(); + struct.success = new ArrayList(_list910.size); + Partition _elem911; + for (int _i912 = 0; _i912 < _list910.size; ++_i912) { - _elem893 = new Partition(); - _elem893.read(iprot); - struct.success.add(_elem893); + _elem911 = new Partition(); + _elem911.read(iprot); + struct.success.add(_elem911); } iprot.readListEnd(); } @@ -85715,9 +87568,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partitions_by_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Partition _iter895 : struct.success) + for (Partition _iter913 : struct.success) { - _iter895.write(oprot); + _iter913.write(oprot); } oprot.writeListEnd(); } @@ -85764,9 +87617,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter896 : struct.success) + for (Partition _iter914 : struct.success) { - _iter896.write(oprot); + _iter914.write(oprot); } } } @@ -85784,14 +87637,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list897 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list897.size); - Partition _elem898; - for (int _i899 = 0; _i899 < _list897.size; ++_i899) + org.apache.thrift.protocol.TList _list915 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list915.size); + Partition _elem916; + for (int _i917 = 0; _i917 < _list915.size; ++_i917) { - _elem898 = new Partition(); - _elem898.read(iprot); - struct.success.add(_elem898); + _elem916 = new Partition(); + _elem916.read(iprot); + struct.success.add(_elem916); } } struct.setSuccessIsSet(true); @@ -87341,14 +89194,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, alter_partitions_ar case 3: // NEW_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list900 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list900.size); - Partition _elem901; - for (int _i902 = 0; _i902 < _list900.size; ++_i902) + org.apache.thrift.protocol.TList _list918 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list918.size); + Partition _elem919; + for (int _i920 = 0; _i920 < _list918.size; ++_i920) { - _elem901 = new Partition(); - _elem901.read(iprot); - struct.new_parts.add(_elem901); + _elem919 = new Partition(); + _elem919.read(iprot); + struct.new_parts.add(_elem919); } iprot.readListEnd(); } @@ -87384,9 +89237,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, alter_partitions_a oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.new_parts.size())); - for (Partition _iter903 : struct.new_parts) + for (Partition _iter921 : struct.new_parts) { - _iter903.write(oprot); + _iter921.write(oprot); } oprot.writeListEnd(); } @@ -87429,9 +89282,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, alter_partitions_ar if (struct.isSetNew_parts()) { { oprot.writeI32(struct.new_parts.size()); - for (Partition _iter904 : struct.new_parts) + for (Partition _iter922 : struct.new_parts) { - _iter904.write(oprot); + _iter922.write(oprot); } } } @@ -87451,14 +89304,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list905 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list905.size); - Partition _elem906; - for (int _i907 = 0; _i907 < _list905.size; ++_i907) + org.apache.thrift.protocol.TList _list923 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list923.size); + Partition _elem924; + for (int _i925 = 0; _i925 < _list923.size; ++_i925) { - _elem906 = new Partition(); - _elem906.read(iprot); - struct.new_parts.add(_elem906); + _elem924 = new Partition(); + _elem924.read(iprot); + struct.new_parts.add(_elem924); } } struct.setNew_partsIsSet(true); @@ -89654,13 +91507,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, rename_partition_ar case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list908 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list908.size); - String _elem909; - for (int _i910 = 0; _i910 < _list908.size; ++_i910) + org.apache.thrift.protocol.TList _list926 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list926.size); + String _elem927; + for (int _i928 = 0; _i928 < _list926.size; ++_i928) { - _elem909 = iprot.readString(); - struct.part_vals.add(_elem909); + _elem927 = iprot.readString(); + struct.part_vals.add(_elem927); } iprot.readListEnd(); } @@ -89705,9 +91558,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, rename_partition_a oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter911 : struct.part_vals) + for (String _iter929 : struct.part_vals) { - oprot.writeString(_iter911); + oprot.writeString(_iter929); } oprot.writeListEnd(); } @@ -89758,9 +91611,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, rename_partition_ar if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter912 : struct.part_vals) + for (String _iter930 : struct.part_vals) { - oprot.writeString(_iter912); + oprot.writeString(_iter930); } } } @@ -89783,13 +91636,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list913 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list913.size); - String _elem914; - for (int _i915 = 0; _i915 < _list913.size; ++_i915) + org.apache.thrift.protocol.TList _list931 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list931.size); + String _elem932; + for (int _i933 = 0; _i933 < _list931.size; ++_i933) { - _elem914 = iprot.readString(); - struct.part_vals.add(_elem914); + _elem932 = iprot.readString(); + struct.part_vals.add(_elem932); } } struct.setPart_valsIsSet(true); @@ -90663,13 +92516,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_has_ case 1: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list916 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list916.size); - String _elem917; - for (int _i918 = 0; _i918 < _list916.size; ++_i918) + org.apache.thrift.protocol.TList _list934 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list934.size); + String _elem935; + for (int _i936 = 0; _i936 < _list934.size; ++_i936) { - _elem917 = iprot.readString(); - struct.part_vals.add(_elem917); + _elem935 = iprot.readString(); + struct.part_vals.add(_elem935); } iprot.readListEnd(); } @@ -90703,9 +92556,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_has oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter919 : struct.part_vals) + for (String _iter937 : struct.part_vals) { - oprot.writeString(_iter919); + oprot.writeString(_iter937); } oprot.writeListEnd(); } @@ -90742,9 +92595,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_has_ if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter920 : struct.part_vals) + for (String _iter938 : struct.part_vals) { - oprot.writeString(_iter920); + oprot.writeString(_iter938); } } } @@ -90759,13 +92612,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_has_v BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list921 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list921.size); - String _elem922; - for (int _i923 = 0; _i923 < _list921.size; ++_i923) + org.apache.thrift.protocol.TList _list939 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list939.size); + String _elem940; + for (int _i941 = 0; _i941 < _list939.size; ++_i941) { - _elem922 = iprot.readString(); - struct.part_vals.add(_elem922); + _elem940 = iprot.readString(); + struct.part_vals.add(_elem940); } } struct.setPart_valsIsSet(true); @@ -92920,13 +94773,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_v case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list924 = iprot.readListBegin(); - struct.success = new ArrayList(_list924.size); - String _elem925; - for (int _i926 = 0; _i926 < _list924.size; ++_i926) + org.apache.thrift.protocol.TList _list942 = iprot.readListBegin(); + struct.success = new ArrayList(_list942.size); + String _elem943; + for (int _i944 = 0; _i944 < _list942.size; ++_i944) { - _elem925 = iprot.readString(); - struct.success.add(_elem925); + _elem943 = iprot.readString(); + struct.success.add(_elem943); } iprot.readListEnd(); } @@ -92961,9 +94814,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter927 : struct.success) + for (String _iter945 : struct.success) { - oprot.writeString(_iter927); + oprot.writeString(_iter945); } oprot.writeListEnd(); } @@ -93002,9 +94855,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter928 : struct.success) + for (String _iter946 : struct.success) { - oprot.writeString(_iter928); + oprot.writeString(_iter946); } } } @@ -93019,13 +94872,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_va BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list929 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list929.size); - String _elem930; - for (int _i931 = 0; _i931 < _list929.size; ++_i931) + org.apache.thrift.protocol.TList _list947 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list947.size); + String _elem948; + for (int _i949 = 0; _i949 < _list947.size; ++_i949) { - _elem930 = iprot.readString(); - struct.success.add(_elem930); + _elem948 = iprot.readString(); + struct.success.add(_elem948); } } struct.setSuccessIsSet(true); @@ -93788,15 +95641,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, partition_name_to_s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map932 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map932.size); - String _key933; - String _val934; - for (int _i935 = 0; _i935 < _map932.size; ++_i935) + org.apache.thrift.protocol.TMap _map950 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map950.size); + String _key951; + String _val952; + for (int _i953 = 0; _i953 < _map950.size; ++_i953) { - _key933 = iprot.readString(); - _val934 = iprot.readString(); - struct.success.put(_key933, _val934); + _key951 = iprot.readString(); + _val952 = iprot.readString(); + struct.success.put(_key951, _val952); } iprot.readMapEnd(); } @@ -93831,10 +95684,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, partition_name_to_ oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (Map.Entry _iter936 : struct.success.entrySet()) + for (Map.Entry _iter954 : struct.success.entrySet()) { - oprot.writeString(_iter936.getKey()); - oprot.writeString(_iter936.getValue()); + oprot.writeString(_iter954.getKey()); + oprot.writeString(_iter954.getValue()); } oprot.writeMapEnd(); } @@ -93873,10 +95726,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Map.Entry _iter937 : struct.success.entrySet()) + for (Map.Entry _iter955 : struct.success.entrySet()) { - oprot.writeString(_iter937.getKey()); - oprot.writeString(_iter937.getValue()); + oprot.writeString(_iter955.getKey()); + oprot.writeString(_iter955.getValue()); } } } @@ -93891,15 +95744,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, partition_name_to_sp BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map938 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap(2*_map938.size); - String _key939; - String _val940; - for (int _i941 = 0; _i941 < _map938.size; ++_i941) + org.apache.thrift.protocol.TMap _map956 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap(2*_map956.size); + String _key957; + String _val958; + for (int _i959 = 0; _i959 < _map956.size; ++_i959) { - _key939 = iprot.readString(); - _val940 = iprot.readString(); - struct.success.put(_key939, _val940); + _key957 = iprot.readString(); + _val958 = iprot.readString(); + struct.success.put(_key957, _val958); } } struct.setSuccessIsSet(true); @@ -94494,15 +96347,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, markPartitionForEve case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map942 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map942.size); - String _key943; - String _val944; - for (int _i945 = 0; _i945 < _map942.size; ++_i945) + org.apache.thrift.protocol.TMap _map960 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map960.size); + String _key961; + String _val962; + for (int _i963 = 0; _i963 < _map960.size; ++_i963) { - _key943 = iprot.readString(); - _val944 = iprot.readString(); - struct.part_vals.put(_key943, _val944); + _key961 = iprot.readString(); + _val962 = iprot.readString(); + struct.part_vals.put(_key961, _val962); } iprot.readMapEnd(); } @@ -94546,10 +96399,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, markPartitionForEv oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter946 : struct.part_vals.entrySet()) + for (Map.Entry _iter964 : struct.part_vals.entrySet()) { - oprot.writeString(_iter946.getKey()); - oprot.writeString(_iter946.getValue()); + oprot.writeString(_iter964.getKey()); + oprot.writeString(_iter964.getValue()); } oprot.writeMapEnd(); } @@ -94600,10 +96453,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter947 : struct.part_vals.entrySet()) + for (Map.Entry _iter965 : struct.part_vals.entrySet()) { - oprot.writeString(_iter947.getKey()); - oprot.writeString(_iter947.getValue()); + oprot.writeString(_iter965.getKey()); + oprot.writeString(_iter965.getValue()); } } } @@ -94626,15 +96479,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map948 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map948.size); - String _key949; - String _val950; - for (int _i951 = 0; _i951 < _map948.size; ++_i951) + org.apache.thrift.protocol.TMap _map966 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map966.size); + String _key967; + String _val968; + for (int _i969 = 0; _i969 < _map966.size; ++_i969) { - _key949 = iprot.readString(); - _val950 = iprot.readString(); - struct.part_vals.put(_key949, _val950); + _key967 = iprot.readString(); + _val968 = iprot.readString(); + struct.part_vals.put(_key967, _val968); } } struct.setPart_valsIsSet(true); @@ -96118,15 +97971,15 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, isPartitionMarkedFo case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { { - org.apache.thrift.protocol.TMap _map952 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map952.size); - String _key953; - String _val954; - for (int _i955 = 0; _i955 < _map952.size; ++_i955) + org.apache.thrift.protocol.TMap _map970 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map970.size); + String _key971; + String _val972; + for (int _i973 = 0; _i973 < _map970.size; ++_i973) { - _key953 = iprot.readString(); - _val954 = iprot.readString(); - struct.part_vals.put(_key953, _val954); + _key971 = iprot.readString(); + _val972 = iprot.readString(); + struct.part_vals.put(_key971, _val972); } iprot.readMapEnd(); } @@ -96170,10 +98023,10 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, isPartitionMarkedF oprot.writeFieldBegin(PART_VALS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (Map.Entry _iter956 : struct.part_vals.entrySet()) + for (Map.Entry _iter974 : struct.part_vals.entrySet()) { - oprot.writeString(_iter956.getKey()); - oprot.writeString(_iter956.getValue()); + oprot.writeString(_iter974.getKey()); + oprot.writeString(_iter974.getValue()); } oprot.writeMapEnd(); } @@ -96224,10 +98077,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter957 : struct.part_vals.entrySet()) + for (Map.Entry _iter975 : struct.part_vals.entrySet()) { - oprot.writeString(_iter957.getKey()); - oprot.writeString(_iter957.getValue()); + oprot.writeString(_iter975.getKey()); + oprot.writeString(_iter975.getValue()); } } } @@ -96250,15 +98103,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map958 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new HashMap(2*_map958.size); - String _key959; - String _val960; - for (int _i961 = 0; _i961 < _map958.size; ++_i961) + org.apache.thrift.protocol.TMap _map976 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new HashMap(2*_map976.size); + String _key977; + String _val978; + for (int _i979 = 0; _i979 < _map976.size; ++_i979) { - _key959 = iprot.readString(); - _val960 = iprot.readString(); - struct.part_vals.put(_key959, _val960); + _key977 = iprot.readString(); + _val978 = iprot.readString(); + struct.part_vals.put(_key977, _val978); } } struct.setPart_valsIsSet(true); @@ -102982,14 +104835,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_indexes_result case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list962 = iprot.readListBegin(); - struct.success = new ArrayList(_list962.size); - Index _elem963; - for (int _i964 = 0; _i964 < _list962.size; ++_i964) + org.apache.thrift.protocol.TList _list980 = iprot.readListBegin(); + struct.success = new ArrayList(_list980.size); + Index _elem981; + for (int _i982 = 0; _i982 < _list980.size; ++_i982) { - _elem963 = new Index(); - _elem963.read(iprot); - struct.success.add(_elem963); + _elem981 = new Index(); + _elem981.read(iprot); + struct.success.add(_elem981); } iprot.readListEnd(); } @@ -103033,9 +104886,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_indexes_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Index _iter965 : struct.success) + for (Index _iter983 : struct.success) { - _iter965.write(oprot); + _iter983.write(oprot); } oprot.writeListEnd(); } @@ -103082,9 +104935,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_indexes_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter966 : struct.success) + for (Index _iter984 : struct.success) { - _iter966.write(oprot); + _iter984.write(oprot); } } } @@ -103102,14 +104955,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_indexes_result s BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list967 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list967.size); - Index _elem968; - for (int _i969 = 0; _i969 < _list967.size; ++_i969) + org.apache.thrift.protocol.TList _list985 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list985.size); + Index _elem986; + for (int _i987 = 0; _i987 < _list985.size; ++_i987) { - _elem968 = new Index(); - _elem968.read(iprot); - struct.success.add(_elem968); + _elem986 = new Index(); + _elem986.read(iprot); + struct.success.add(_elem986); } } struct.setSuccessIsSet(true); @@ -104088,13 +105941,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_index_names_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list970 = iprot.readListBegin(); - struct.success = new ArrayList(_list970.size); - String _elem971; - for (int _i972 = 0; _i972 < _list970.size; ++_i972) + org.apache.thrift.protocol.TList _list988 = iprot.readListBegin(); + struct.success = new ArrayList(_list988.size); + String _elem989; + for (int _i990 = 0; _i990 < _list988.size; ++_i990) { - _elem971 = iprot.readString(); - struct.success.add(_elem971); + _elem989 = iprot.readString(); + struct.success.add(_elem989); } iprot.readListEnd(); } @@ -104129,9 +105982,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_index_names_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter973 : struct.success) + for (String _iter991 : struct.success) { - oprot.writeString(_iter973); + oprot.writeString(_iter991); } oprot.writeListEnd(); } @@ -104170,9 +106023,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_index_names_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter974 : struct.success) + for (String _iter992 : struct.success) { - oprot.writeString(_iter974); + oprot.writeString(_iter992); } } } @@ -104187,13 +106040,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_index_names_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list975 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list975.size); - String _elem976; - for (int _i977 = 0; _i977 < _list975.size; ++_i977) + org.apache.thrift.protocol.TList _list993 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list993.size); + String _elem994; + for (int _i995 = 0; _i995 < _list993.size; ++_i995) { - _elem976 = iprot.readString(); - struct.success.add(_elem976); + _elem994 = iprot.readString(); + struct.success.add(_elem994); } } struct.setSuccessIsSet(true); @@ -119928,13 +121781,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_functions_resul case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list978 = iprot.readListBegin(); - struct.success = new ArrayList(_list978.size); - String _elem979; - for (int _i980 = 0; _i980 < _list978.size; ++_i980) + org.apache.thrift.protocol.TList _list996 = iprot.readListBegin(); + struct.success = new ArrayList(_list996.size); + String _elem997; + for (int _i998 = 0; _i998 < _list996.size; ++_i998) { - _elem979 = iprot.readString(); - struct.success.add(_elem979); + _elem997 = iprot.readString(); + struct.success.add(_elem997); } iprot.readListEnd(); } @@ -119969,9 +121822,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_functions_resu oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter981 : struct.success) + for (String _iter999 : struct.success) { - oprot.writeString(_iter981); + oprot.writeString(_iter999); } oprot.writeListEnd(); } @@ -120010,9 +121863,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter982 : struct.success) + for (String _iter1000 : struct.success) { - oprot.writeString(_iter982); + oprot.writeString(_iter1000); } } } @@ -120027,13 +121880,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_functions_result BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list983 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list983.size); - String _elem984; - for (int _i985 = 0; _i985 < _list983.size; ++_i985) + org.apache.thrift.protocol.TList _list1001 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1001.size); + String _elem1002; + for (int _i1003 = 0; _i1003 < _list1001.size; ++_i1003) { - _elem984 = iprot.readString(); - struct.success.add(_elem984); + _elem1002 = iprot.readString(); + struct.success.add(_elem1002); } } struct.setSuccessIsSet(true); @@ -124088,13 +125941,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_role_names_resu case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list986 = iprot.readListBegin(); - struct.success = new ArrayList(_list986.size); - String _elem987; - for (int _i988 = 0; _i988 < _list986.size; ++_i988) + org.apache.thrift.protocol.TList _list1004 = iprot.readListBegin(); + struct.success = new ArrayList(_list1004.size); + String _elem1005; + for (int _i1006 = 0; _i1006 < _list1004.size; ++_i1006) { - _elem987 = iprot.readString(); - struct.success.add(_elem987); + _elem1005 = iprot.readString(); + struct.success.add(_elem1005); } iprot.readListEnd(); } @@ -124129,9 +125982,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_role_names_res oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter989 : struct.success) + for (String _iter1007 : struct.success) { - oprot.writeString(_iter989); + oprot.writeString(_iter1007); } oprot.writeListEnd(); } @@ -124170,9 +126023,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter990 : struct.success) + for (String _iter1008 : struct.success) { - oprot.writeString(_iter990); + oprot.writeString(_iter1008); } } } @@ -124187,13 +126040,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_role_names_resul BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list991 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list991.size); - String _elem992; - for (int _i993 = 0; _i993 < _list991.size; ++_i993) + org.apache.thrift.protocol.TList _list1009 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1009.size); + String _elem1010; + for (int _i1011 = 0; _i1011 < _list1009.size; ++_i1011) { - _elem992 = iprot.readString(); - struct.success.add(_elem992); + _elem1010 = iprot.readString(); + struct.success.add(_elem1010); } } struct.setSuccessIsSet(true); @@ -127484,14 +129337,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_roles_result s case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list994 = iprot.readListBegin(); - struct.success = new ArrayList(_list994.size); - Role _elem995; - for (int _i996 = 0; _i996 < _list994.size; ++_i996) + org.apache.thrift.protocol.TList _list1012 = iprot.readListBegin(); + struct.success = new ArrayList(_list1012.size); + Role _elem1013; + for (int _i1014 = 0; _i1014 < _list1012.size; ++_i1014) { - _elem995 = new Role(); - _elem995.read(iprot); - struct.success.add(_elem995); + _elem1013 = new Role(); + _elem1013.read(iprot); + struct.success.add(_elem1013); } iprot.readListEnd(); } @@ -127526,9 +129379,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_roles_result oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (Role _iter997 : struct.success) + for (Role _iter1015 : struct.success) { - _iter997.write(oprot); + _iter1015.write(oprot); } oprot.writeListEnd(); } @@ -127567,9 +129420,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter998 : struct.success) + for (Role _iter1016 : struct.success) { - _iter998.write(oprot); + _iter1016.write(oprot); } } } @@ -127584,14 +129437,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_roles_result st BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list999 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list999.size); - Role _elem1000; - for (int _i1001 = 0; _i1001 < _list999.size; ++_i1001) + org.apache.thrift.protocol.TList _list1017 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1017.size); + Role _elem1018; + for (int _i1019 = 0; _i1019 < _list1017.size; ++_i1019) { - _elem1000 = new Role(); - _elem1000.read(iprot); - struct.success.add(_elem1000); + _elem1018 = new Role(); + _elem1018.read(iprot); + struct.success.add(_elem1018); } } struct.setSuccessIsSet(true); @@ -130596,13 +132449,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_privilege_set_a case 3: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1002 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1002.size); - String _elem1003; - for (int _i1004 = 0; _i1004 < _list1002.size; ++_i1004) + org.apache.thrift.protocol.TList _list1020 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1020.size); + String _elem1021; + for (int _i1022 = 0; _i1022 < _list1020.size; ++_i1022) { - _elem1003 = iprot.readString(); - struct.group_names.add(_elem1003); + _elem1021 = iprot.readString(); + struct.group_names.add(_elem1021); } iprot.readListEnd(); } @@ -130638,9 +132491,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_privilege_set_ oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1005 : struct.group_names) + for (String _iter1023 : struct.group_names) { - oprot.writeString(_iter1005); + oprot.writeString(_iter1023); } oprot.writeListEnd(); } @@ -130683,9 +132536,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_a if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1006 : struct.group_names) + for (String _iter1024 : struct.group_names) { - oprot.writeString(_iter1006); + oprot.writeString(_iter1024); } } } @@ -130706,13 +132559,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list1007 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1007.size); - String _elem1008; - for (int _i1009 = 0; _i1009 < _list1007.size; ++_i1009) + org.apache.thrift.protocol.TList _list1025 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1025.size); + String _elem1026; + for (int _i1027 = 0; _i1027 < _list1025.size; ++_i1027) { - _elem1008 = iprot.readString(); - struct.group_names.add(_elem1008); + _elem1026 = iprot.readString(); + struct.group_names.add(_elem1026); } } struct.setGroup_namesIsSet(true); @@ -132170,14 +134023,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, list_privileges_res case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1010 = iprot.readListBegin(); - struct.success = new ArrayList(_list1010.size); - HiveObjectPrivilege _elem1011; - for (int _i1012 = 0; _i1012 < _list1010.size; ++_i1012) + org.apache.thrift.protocol.TList _list1028 = iprot.readListBegin(); + struct.success = new ArrayList(_list1028.size); + HiveObjectPrivilege _elem1029; + for (int _i1030 = 0; _i1030 < _list1028.size; ++_i1030) { - _elem1011 = new HiveObjectPrivilege(); - _elem1011.read(iprot); - struct.success.add(_elem1011); + _elem1029 = new HiveObjectPrivilege(); + _elem1029.read(iprot); + struct.success.add(_elem1029); } iprot.readListEnd(); } @@ -132212,9 +134065,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, list_privileges_re oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size())); - for (HiveObjectPrivilege _iter1013 : struct.success) + for (HiveObjectPrivilege _iter1031 : struct.success) { - _iter1013.write(oprot); + _iter1031.write(oprot); } oprot.writeListEnd(); } @@ -132253,9 +134106,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter1014 : struct.success) + for (HiveObjectPrivilege _iter1032 : struct.success) { - _iter1014.write(oprot); + _iter1032.write(oprot); } } } @@ -132270,14 +134123,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, list_privileges_resu BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1015 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list1015.size); - HiveObjectPrivilege _elem1016; - for (int _i1017 = 0; _i1017 < _list1015.size; ++_i1017) + org.apache.thrift.protocol.TList _list1033 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list1033.size); + HiveObjectPrivilege _elem1034; + for (int _i1035 = 0; _i1035 < _list1033.size; ++_i1035) { - _elem1016 = new HiveObjectPrivilege(); - _elem1016.read(iprot); - struct.success.add(_elem1016); + _elem1034 = new HiveObjectPrivilege(); + _elem1034.read(iprot); + struct.success.add(_elem1034); } } struct.setSuccessIsSet(true); @@ -135179,13 +137032,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_args struct case 2: // GROUP_NAMES if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1018 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list1018.size); - String _elem1019; - for (int _i1020 = 0; _i1020 < _list1018.size; ++_i1020) + org.apache.thrift.protocol.TList _list1036 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list1036.size); + String _elem1037; + for (int _i1038 = 0; _i1038 < _list1036.size; ++_i1038) { - _elem1019 = iprot.readString(); - struct.group_names.add(_elem1019); + _elem1037 = iprot.readString(); + struct.group_names.add(_elem1037); } iprot.readListEnd(); } @@ -135216,9 +137069,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_args struc oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.group_names.size())); - for (String _iter1021 : struct.group_names) + for (String _iter1039 : struct.group_names) { - oprot.writeString(_iter1021); + oprot.writeString(_iter1039); } oprot.writeListEnd(); } @@ -135255,9 +137108,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct if (struct.isSetGroup_names()) { { oprot.writeI32(struct.group_names.size()); - for (String _iter1022 : struct.group_names) + for (String _iter1040 : struct.group_names) { - oprot.writeString(_iter1022); + oprot.writeString(_iter1040); } } } @@ -135273,13 +137126,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list1023 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list1023.size); - String _elem1024; - for (int _i1025 = 0; _i1025 < _list1023.size; ++_i1025) + org.apache.thrift.protocol.TList _list1041 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list1041.size); + String _elem1042; + for (int _i1043 = 0; _i1043 < _list1041.size; ++_i1043) { - _elem1024 = iprot.readString(); - struct.group_names.add(_elem1024); + _elem1042 = iprot.readString(); + struct.group_names.add(_elem1042); } } struct.setGroup_namesIsSet(true); @@ -135682,13 +137535,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, set_ugi_result stru case 0: // SUCCESS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list1026 = iprot.readListBegin(); - struct.success = new ArrayList(_list1026.size); - String _elem1027; - for (int _i1028 = 0; _i1028 < _list1026.size; ++_i1028) + org.apache.thrift.protocol.TList _list1044 = iprot.readListBegin(); + struct.success = new ArrayList(_list1044.size); + String _elem1045; + for (int _i1046 = 0; _i1046 < _list1044.size; ++_i1046) { - _elem1027 = iprot.readString(); - struct.success.add(_elem1027); + _elem1045 = iprot.readString(); + struct.success.add(_elem1045); } iprot.readListEnd(); } @@ -135723,9 +137576,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, set_ugi_result str oprot.writeFieldBegin(SUCCESS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.success.size())); - for (String _iter1029 : struct.success) + for (String _iter1047 : struct.success) { - oprot.writeString(_iter1029); + oprot.writeString(_iter1047); } oprot.writeListEnd(); } @@ -135764,9 +137617,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter1030 : struct.success) + for (String _iter1048 : struct.success) { - oprot.writeString(_iter1030); + oprot.writeString(_iter1048); } } } @@ -135781,13 +137634,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_result struc BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list1031 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list1031.size); - String _elem1032; - for (int _i1033 = 0; _i1033 < _list1031.size; ++_i1033) + org.apache.thrift.protocol.TList _list1049 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list1049.size); + String _elem1050; + for (int _i1051 = 0; _i1051 < _list1049.size; ++_i1051) { - _elem1032 = iprot.readString(); - struct.success.add(_elem1032); + _elem1050 = iprot.readString(); + struct.success.add(_elem1050); } } struct.setSuccessIsSet(true); diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index e922d7d..a6862be 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -394,6 +394,19 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { */ public function exchange_partition(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name); /** + * @param array $partitionSpecs + * @param string $source_db + * @param string $source_table_name + * @param string $dest_db + * @param string $dest_table_name + * @return \metastore\Partition[] + * @throws \metastore\MetaException + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\InvalidInputException + */ + public function exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name); + /** * @param string $db_name * @param string $tbl_name * @param string[] $part_vals @@ -3622,6 +3635,73 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("exchange_partition failed: unknown result"); } + public function exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name) + { + $this->send_exchange_partitions($partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name); + return $this->recv_exchange_partitions(); + } + + public function send_exchange_partitions(array $partitionSpecs, $source_db, $source_table_name, $dest_db, $dest_table_name) + { + $args = new \metastore\ThriftHiveMetastore_exchange_partitions_args(); + $args->partitionSpecs = $partitionSpecs; + $args->source_db = $source_db; + $args->source_table_name = $source_table_name; + $args->dest_db = $dest_db; + $args->dest_table_name = $dest_table_name; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'exchange_partitions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('exchange_partitions', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_exchange_partitions() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_exchange_partitions_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_exchange_partitions_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + if ($result->o4 !== null) { + throw $result->o4; + } + throw new \Exception("exchange_partitions failed: unknown result"); + } + public function get_partition_with_auth($db_name, $tbl_name, array $part_vals, $user_name, array $group_names) { $this->send_get_partition_with_auth($db_name, $tbl_name, $part_vals, $user_name, $group_names); @@ -19473,6 +19553,410 @@ class ThriftHiveMetastore_exchange_partition_result { } +class ThriftHiveMetastore_exchange_partitions_args { + static $_TSPEC; + + /** + * @var array + */ + public $partitionSpecs = null; + /** + * @var string + */ + public $source_db = null; + /** + * @var string + */ + public $source_table_name = null; + /** + * @var string + */ + public $dest_db = null; + /** + * @var string + */ + public $dest_table_name = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'partitionSpecs', + 'type' => TType::MAP, + 'ktype' => TType::STRING, + 'vtype' => TType::STRING, + 'key' => array( + 'type' => TType::STRING, + ), + 'val' => array( + 'type' => TType::STRING, + ), + ), + 2 => array( + 'var' => 'source_db', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'source_table_name', + 'type' => TType::STRING, + ), + 4 => array( + 'var' => 'dest_db', + 'type' => TType::STRING, + ), + 5 => array( + 'var' => 'dest_table_name', + 'type' => TType::STRING, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['partitionSpecs'])) { + $this->partitionSpecs = $vals['partitionSpecs']; + } + if (isset($vals['source_db'])) { + $this->source_db = $vals['source_db']; + } + if (isset($vals['source_table_name'])) { + $this->source_table_name = $vals['source_table_name']; + } + if (isset($vals['dest_db'])) { + $this->dest_db = $vals['dest_db']; + } + if (isset($vals['dest_table_name'])) { + $this->dest_table_name = $vals['dest_table_name']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_exchange_partitions_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::MAP) { + $this->partitionSpecs = array(); + $_size669 = 0; + $_ktype670 = 0; + $_vtype671 = 0; + $xfer += $input->readMapBegin($_ktype670, $_vtype671, $_size669); + for ($_i673 = 0; $_i673 < $_size669; ++$_i673) + { + $key674 = ''; + $val675 = ''; + $xfer += $input->readString($key674); + $xfer += $input->readString($val675); + $this->partitionSpecs[$key674] = $val675; + } + $xfer += $input->readMapEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->source_db); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->source_table_name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->dest_db); + } else { + $xfer += $input->skip($ftype); + } + break; + case 5: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->dest_table_name); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_exchange_partitions_args'); + if ($this->partitionSpecs !== null) { + if (!is_array($this->partitionSpecs)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('partitionSpecs', TType::MAP, 1); + { + $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); + { + foreach ($this->partitionSpecs as $kiter676 => $viter677) + { + $xfer += $output->writeString($kiter676); + $xfer += $output->writeString($viter677); + } + } + $output->writeMapEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->source_db !== null) { + $xfer += $output->writeFieldBegin('source_db', TType::STRING, 2); + $xfer += $output->writeString($this->source_db); + $xfer += $output->writeFieldEnd(); + } + if ($this->source_table_name !== null) { + $xfer += $output->writeFieldBegin('source_table_name', TType::STRING, 3); + $xfer += $output->writeString($this->source_table_name); + $xfer += $output->writeFieldEnd(); + } + if ($this->dest_db !== null) { + $xfer += $output->writeFieldBegin('dest_db', TType::STRING, 4); + $xfer += $output->writeString($this->dest_db); + $xfer += $output->writeFieldEnd(); + } + if ($this->dest_table_name !== null) { + $xfer += $output->writeFieldBegin('dest_table_name', TType::STRING, 5); + $xfer += $output->writeString($this->dest_table_name); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_exchange_partitions_result { + static $_TSPEC; + + /** + * @var \metastore\Partition[] + */ + public $success = null; + /** + * @var \metastore\MetaException + */ + public $o1 = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o2 = null; + /** + * @var \metastore\InvalidObjectException + */ + public $o3 = null; + /** + * @var \metastore\InvalidInputException + */ + public $o4 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::LST, + 'etype' => TType::STRUCT, + 'elem' => array( + 'type' => TType::STRUCT, + 'class' => '\metastore\Partition', + ), + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidInputException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_exchange_partitions_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::LST) { + $this->success = array(); + $_size678 = 0; + $_etype681 = 0; + $xfer += $input->readListBegin($_etype681, $_size678); + for ($_i682 = 0; $_i682 < $_size678; ++$_i682) + { + $elem683 = null; + $elem683 = new \metastore\Partition(); + $xfer += $elem683->read($input); + $this->success []= $elem683; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\MetaException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\NoSuchObjectException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\InvalidObjectException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\InvalidInputException(); + $xfer += $this->o4->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_exchange_partitions_result'); + if ($this->success !== null) { + if (!is_array($this->success)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('success', TType::LST, 0); + { + $output->writeListBegin(TType::STRUCT, count($this->success)); + { + foreach ($this->success as $iter684) + { + $xfer += $iter684->write($output); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o4 !== null) { + $xfer += $output->writeFieldBegin('o4', TType::STRUCT, 4); + $xfer += $this->o4->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_get_partition_with_auth_args { static $_TSPEC; @@ -19585,14 +20069,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size669 = 0; - $_etype672 = 0; - $xfer += $input->readListBegin($_etype672, $_size669); - for ($_i673 = 0; $_i673 < $_size669; ++$_i673) + $_size685 = 0; + $_etype688 = 0; + $xfer += $input->readListBegin($_etype688, $_size685); + for ($_i689 = 0; $_i689 < $_size685; ++$_i689) { - $elem674 = null; - $xfer += $input->readString($elem674); - $this->part_vals []= $elem674; + $elem690 = null; + $xfer += $input->readString($elem690); + $this->part_vals []= $elem690; } $xfer += $input->readListEnd(); } else { @@ -19609,14 +20093,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size675 = 0; - $_etype678 = 0; - $xfer += $input->readListBegin($_etype678, $_size675); - for ($_i679 = 0; $_i679 < $_size675; ++$_i679) + $_size691 = 0; + $_etype694 = 0; + $xfer += $input->readListBegin($_etype694, $_size691); + for ($_i695 = 0; $_i695 < $_size691; ++$_i695) { - $elem680 = null; - $xfer += $input->readString($elem680); - $this->group_names []= $elem680; + $elem696 = null; + $xfer += $input->readString($elem696); + $this->group_names []= $elem696; } $xfer += $input->readListEnd(); } else { @@ -19654,9 +20138,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter681) + foreach ($this->part_vals as $iter697) { - $xfer += $output->writeString($iter681); + $xfer += $output->writeString($iter697); } } $output->writeListEnd(); @@ -19676,9 +20160,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter682) + foreach ($this->group_names as $iter698) { - $xfer += $output->writeString($iter682); + $xfer += $output->writeString($iter698); } } $output->writeListEnd(); @@ -20269,15 +20753,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size683 = 0; - $_etype686 = 0; - $xfer += $input->readListBegin($_etype686, $_size683); - for ($_i687 = 0; $_i687 < $_size683; ++$_i687) + $_size699 = 0; + $_etype702 = 0; + $xfer += $input->readListBegin($_etype702, $_size699); + for ($_i703 = 0; $_i703 < $_size699; ++$_i703) { - $elem688 = null; - $elem688 = new \metastore\Partition(); - $xfer += $elem688->read($input); - $this->success []= $elem688; + $elem704 = null; + $elem704 = new \metastore\Partition(); + $xfer += $elem704->read($input); + $this->success []= $elem704; } $xfer += $input->readListEnd(); } else { @@ -20321,9 +20805,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter689) + foreach ($this->success as $iter705) { - $xfer += $iter689->write($output); + $xfer += $iter705->write($output); } } $output->writeListEnd(); @@ -20469,14 +20953,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size690 = 0; - $_etype693 = 0; - $xfer += $input->readListBegin($_etype693, $_size690); - for ($_i694 = 0; $_i694 < $_size690; ++$_i694) + $_size706 = 0; + $_etype709 = 0; + $xfer += $input->readListBegin($_etype709, $_size706); + for ($_i710 = 0; $_i710 < $_size706; ++$_i710) { - $elem695 = null; - $xfer += $input->readString($elem695); - $this->group_names []= $elem695; + $elem711 = null; + $xfer += $input->readString($elem711); + $this->group_names []= $elem711; } $xfer += $input->readListEnd(); } else { @@ -20524,9 +21008,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter696) + foreach ($this->group_names as $iter712) { - $xfer += $output->writeString($iter696); + $xfer += $output->writeString($iter712); } } $output->writeListEnd(); @@ -20615,15 +21099,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size697 = 0; - $_etype700 = 0; - $xfer += $input->readListBegin($_etype700, $_size697); - for ($_i701 = 0; $_i701 < $_size697; ++$_i701) + $_size713 = 0; + $_etype716 = 0; + $xfer += $input->readListBegin($_etype716, $_size713); + for ($_i717 = 0; $_i717 < $_size713; ++$_i717) { - $elem702 = null; - $elem702 = new \metastore\Partition(); - $xfer += $elem702->read($input); - $this->success []= $elem702; + $elem718 = null; + $elem718 = new \metastore\Partition(); + $xfer += $elem718->read($input); + $this->success []= $elem718; } $xfer += $input->readListEnd(); } else { @@ -20667,9 +21151,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter703) + foreach ($this->success as $iter719) { - $xfer += $iter703->write($output); + $xfer += $iter719->write($output); } } $output->writeListEnd(); @@ -20889,15 +21373,15 @@ class ThriftHiveMetastore_get_partitions_pspec_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size704 = 0; - $_etype707 = 0; - $xfer += $input->readListBegin($_etype707, $_size704); - for ($_i708 = 0; $_i708 < $_size704; ++$_i708) + $_size720 = 0; + $_etype723 = 0; + $xfer += $input->readListBegin($_etype723, $_size720); + for ($_i724 = 0; $_i724 < $_size720; ++$_i724) { - $elem709 = null; - $elem709 = new \metastore\PartitionSpec(); - $xfer += $elem709->read($input); - $this->success []= $elem709; + $elem725 = null; + $elem725 = new \metastore\PartitionSpec(); + $xfer += $elem725->read($input); + $this->success []= $elem725; } $xfer += $input->readListEnd(); } else { @@ -20941,9 +21425,9 @@ class ThriftHiveMetastore_get_partitions_pspec_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter710) + foreach ($this->success as $iter726) { - $xfer += $iter710->write($output); + $xfer += $iter726->write($output); } } $output->writeListEnd(); @@ -21150,14 +21634,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size711 = 0; - $_etype714 = 0; - $xfer += $input->readListBegin($_etype714, $_size711); - for ($_i715 = 0; $_i715 < $_size711; ++$_i715) + $_size727 = 0; + $_etype730 = 0; + $xfer += $input->readListBegin($_etype730, $_size727); + for ($_i731 = 0; $_i731 < $_size727; ++$_i731) { - $elem716 = null; - $xfer += $input->readString($elem716); - $this->success []= $elem716; + $elem732 = null; + $xfer += $input->readString($elem732); + $this->success []= $elem732; } $xfer += $input->readListEnd(); } else { @@ -21193,9 +21677,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter717) + foreach ($this->success as $iter733) { - $xfer += $output->writeString($iter717); + $xfer += $output->writeString($iter733); } } $output->writeListEnd(); @@ -21311,14 +21795,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size718 = 0; - $_etype721 = 0; - $xfer += $input->readListBegin($_etype721, $_size718); - for ($_i722 = 0; $_i722 < $_size718; ++$_i722) + $_size734 = 0; + $_etype737 = 0; + $xfer += $input->readListBegin($_etype737, $_size734); + for ($_i738 = 0; $_i738 < $_size734; ++$_i738) { - $elem723 = null; - $xfer += $input->readString($elem723); - $this->part_vals []= $elem723; + $elem739 = null; + $xfer += $input->readString($elem739); + $this->part_vals []= $elem739; } $xfer += $input->readListEnd(); } else { @@ -21363,9 +21847,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter724) + foreach ($this->part_vals as $iter740) { - $xfer += $output->writeString($iter724); + $xfer += $output->writeString($iter740); } } $output->writeListEnd(); @@ -21459,15 +21943,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size725 = 0; - $_etype728 = 0; - $xfer += $input->readListBegin($_etype728, $_size725); - for ($_i729 = 0; $_i729 < $_size725; ++$_i729) + $_size741 = 0; + $_etype744 = 0; + $xfer += $input->readListBegin($_etype744, $_size741); + for ($_i745 = 0; $_i745 < $_size741; ++$_i745) { - $elem730 = null; - $elem730 = new \metastore\Partition(); - $xfer += $elem730->read($input); - $this->success []= $elem730; + $elem746 = null; + $elem746 = new \metastore\Partition(); + $xfer += $elem746->read($input); + $this->success []= $elem746; } $xfer += $input->readListEnd(); } else { @@ -21511,9 +21995,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter731) + foreach ($this->success as $iter747) { - $xfer += $iter731->write($output); + $xfer += $iter747->write($output); } } $output->writeListEnd(); @@ -21660,14 +22144,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size732 = 0; - $_etype735 = 0; - $xfer += $input->readListBegin($_etype735, $_size732); - for ($_i736 = 0; $_i736 < $_size732; ++$_i736) + $_size748 = 0; + $_etype751 = 0; + $xfer += $input->readListBegin($_etype751, $_size748); + for ($_i752 = 0; $_i752 < $_size748; ++$_i752) { - $elem737 = null; - $xfer += $input->readString($elem737); - $this->part_vals []= $elem737; + $elem753 = null; + $xfer += $input->readString($elem753); + $this->part_vals []= $elem753; } $xfer += $input->readListEnd(); } else { @@ -21691,14 +22175,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size738 = 0; - $_etype741 = 0; - $xfer += $input->readListBegin($_etype741, $_size738); - for ($_i742 = 0; $_i742 < $_size738; ++$_i742) + $_size754 = 0; + $_etype757 = 0; + $xfer += $input->readListBegin($_etype757, $_size754); + for ($_i758 = 0; $_i758 < $_size754; ++$_i758) { - $elem743 = null; - $xfer += $input->readString($elem743); - $this->group_names []= $elem743; + $elem759 = null; + $xfer += $input->readString($elem759); + $this->group_names []= $elem759; } $xfer += $input->readListEnd(); } else { @@ -21736,9 +22220,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter744) + foreach ($this->part_vals as $iter760) { - $xfer += $output->writeString($iter744); + $xfer += $output->writeString($iter760); } } $output->writeListEnd(); @@ -21763,9 +22247,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter745) + foreach ($this->group_names as $iter761) { - $xfer += $output->writeString($iter745); + $xfer += $output->writeString($iter761); } } $output->writeListEnd(); @@ -21854,15 +22338,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size746 = 0; - $_etype749 = 0; - $xfer += $input->readListBegin($_etype749, $_size746); - for ($_i750 = 0; $_i750 < $_size746; ++$_i750) + $_size762 = 0; + $_etype765 = 0; + $xfer += $input->readListBegin($_etype765, $_size762); + for ($_i766 = 0; $_i766 < $_size762; ++$_i766) { - $elem751 = null; - $elem751 = new \metastore\Partition(); - $xfer += $elem751->read($input); - $this->success []= $elem751; + $elem767 = null; + $elem767 = new \metastore\Partition(); + $xfer += $elem767->read($input); + $this->success []= $elem767; } $xfer += $input->readListEnd(); } else { @@ -21906,9 +22390,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter752) + foreach ($this->success as $iter768) { - $xfer += $iter752->write($output); + $xfer += $iter768->write($output); } } $output->writeListEnd(); @@ -22029,14 +22513,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size753 = 0; - $_etype756 = 0; - $xfer += $input->readListBegin($_etype756, $_size753); - for ($_i757 = 0; $_i757 < $_size753; ++$_i757) + $_size769 = 0; + $_etype772 = 0; + $xfer += $input->readListBegin($_etype772, $_size769); + for ($_i773 = 0; $_i773 < $_size769; ++$_i773) { - $elem758 = null; - $xfer += $input->readString($elem758); - $this->part_vals []= $elem758; + $elem774 = null; + $xfer += $input->readString($elem774); + $this->part_vals []= $elem774; } $xfer += $input->readListEnd(); } else { @@ -22081,9 +22565,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter759) + foreach ($this->part_vals as $iter775) { - $xfer += $output->writeString($iter759); + $xfer += $output->writeString($iter775); } } $output->writeListEnd(); @@ -22176,14 +22660,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size760 = 0; - $_etype763 = 0; - $xfer += $input->readListBegin($_etype763, $_size760); - for ($_i764 = 0; $_i764 < $_size760; ++$_i764) + $_size776 = 0; + $_etype779 = 0; + $xfer += $input->readListBegin($_etype779, $_size776); + for ($_i780 = 0; $_i780 < $_size776; ++$_i780) { - $elem765 = null; - $xfer += $input->readString($elem765); - $this->success []= $elem765; + $elem781 = null; + $xfer += $input->readString($elem781); + $this->success []= $elem781; } $xfer += $input->readListEnd(); } else { @@ -22227,9 +22711,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter766) + foreach ($this->success as $iter782) { - $xfer += $output->writeString($iter766); + $xfer += $output->writeString($iter782); } } $output->writeListEnd(); @@ -22472,15 +22956,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size767 = 0; - $_etype770 = 0; - $xfer += $input->readListBegin($_etype770, $_size767); - for ($_i771 = 0; $_i771 < $_size767; ++$_i771) + $_size783 = 0; + $_etype786 = 0; + $xfer += $input->readListBegin($_etype786, $_size783); + for ($_i787 = 0; $_i787 < $_size783; ++$_i787) { - $elem772 = null; - $elem772 = new \metastore\Partition(); - $xfer += $elem772->read($input); - $this->success []= $elem772; + $elem788 = null; + $elem788 = new \metastore\Partition(); + $xfer += $elem788->read($input); + $this->success []= $elem788; } $xfer += $input->readListEnd(); } else { @@ -22524,9 +23008,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter773) + foreach ($this->success as $iter789) { - $xfer += $iter773->write($output); + $xfer += $iter789->write($output); } } $output->writeListEnd(); @@ -22769,15 +23253,15 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size774 = 0; - $_etype777 = 0; - $xfer += $input->readListBegin($_etype777, $_size774); - for ($_i778 = 0; $_i778 < $_size774; ++$_i778) + $_size790 = 0; + $_etype793 = 0; + $xfer += $input->readListBegin($_etype793, $_size790); + for ($_i794 = 0; $_i794 < $_size790; ++$_i794) { - $elem779 = null; - $elem779 = new \metastore\PartitionSpec(); - $xfer += $elem779->read($input); - $this->success []= $elem779; + $elem795 = null; + $elem795 = new \metastore\PartitionSpec(); + $xfer += $elem795->read($input); + $this->success []= $elem795; } $xfer += $input->readListEnd(); } else { @@ -22821,9 +23305,9 @@ class ThriftHiveMetastore_get_part_specs_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter780) + foreach ($this->success as $iter796) { - $xfer += $iter780->write($output); + $xfer += $iter796->write($output); } } $output->writeListEnd(); @@ -23143,14 +23627,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size781 = 0; - $_etype784 = 0; - $xfer += $input->readListBegin($_etype784, $_size781); - for ($_i785 = 0; $_i785 < $_size781; ++$_i785) + $_size797 = 0; + $_etype800 = 0; + $xfer += $input->readListBegin($_etype800, $_size797); + for ($_i801 = 0; $_i801 < $_size797; ++$_i801) { - $elem786 = null; - $xfer += $input->readString($elem786); - $this->names []= $elem786; + $elem802 = null; + $xfer += $input->readString($elem802); + $this->names []= $elem802; } $xfer += $input->readListEnd(); } else { @@ -23188,9 +23672,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter787) + foreach ($this->names as $iter803) { - $xfer += $output->writeString($iter787); + $xfer += $output->writeString($iter803); } } $output->writeListEnd(); @@ -23279,15 +23763,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size788 = 0; - $_etype791 = 0; - $xfer += $input->readListBegin($_etype791, $_size788); - for ($_i792 = 0; $_i792 < $_size788; ++$_i792) + $_size804 = 0; + $_etype807 = 0; + $xfer += $input->readListBegin($_etype807, $_size804); + for ($_i808 = 0; $_i808 < $_size804; ++$_i808) { - $elem793 = null; - $elem793 = new \metastore\Partition(); - $xfer += $elem793->read($input); - $this->success []= $elem793; + $elem809 = null; + $elem809 = new \metastore\Partition(); + $xfer += $elem809->read($input); + $this->success []= $elem809; } $xfer += $input->readListEnd(); } else { @@ -23331,9 +23815,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter794) + foreach ($this->success as $iter810) { - $xfer += $iter794->write($output); + $xfer += $iter810->write($output); } } $output->writeListEnd(); @@ -23672,15 +24156,15 @@ class ThriftHiveMetastore_alter_partitions_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size795 = 0; - $_etype798 = 0; - $xfer += $input->readListBegin($_etype798, $_size795); - for ($_i799 = 0; $_i799 < $_size795; ++$_i799) + $_size811 = 0; + $_etype814 = 0; + $xfer += $input->readListBegin($_etype814, $_size811); + for ($_i815 = 0; $_i815 < $_size811; ++$_i815) { - $elem800 = null; - $elem800 = new \metastore\Partition(); - $xfer += $elem800->read($input); - $this->new_parts []= $elem800; + $elem816 = null; + $elem816 = new \metastore\Partition(); + $xfer += $elem816->read($input); + $this->new_parts []= $elem816; } $xfer += $input->readListEnd(); } else { @@ -23718,9 +24202,9 @@ class ThriftHiveMetastore_alter_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter801) + foreach ($this->new_parts as $iter817) { - $xfer += $iter801->write($output); + $xfer += $iter817->write($output); } } $output->writeListEnd(); @@ -24190,14 +24674,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size802 = 0; - $_etype805 = 0; - $xfer += $input->readListBegin($_etype805, $_size802); - for ($_i806 = 0; $_i806 < $_size802; ++$_i806) + $_size818 = 0; + $_etype821 = 0; + $xfer += $input->readListBegin($_etype821, $_size818); + for ($_i822 = 0; $_i822 < $_size818; ++$_i822) { - $elem807 = null; - $xfer += $input->readString($elem807); - $this->part_vals []= $elem807; + $elem823 = null; + $xfer += $input->readString($elem823); + $this->part_vals []= $elem823; } $xfer += $input->readListEnd(); } else { @@ -24243,9 +24727,9 @@ class ThriftHiveMetastore_rename_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter808) + foreach ($this->part_vals as $iter824) { - $xfer += $output->writeString($iter808); + $xfer += $output->writeString($iter824); } } $output->writeListEnd(); @@ -24430,14 +24914,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size809 = 0; - $_etype812 = 0; - $xfer += $input->readListBegin($_etype812, $_size809); - for ($_i813 = 0; $_i813 < $_size809; ++$_i813) + $_size825 = 0; + $_etype828 = 0; + $xfer += $input->readListBegin($_etype828, $_size825); + for ($_i829 = 0; $_i829 < $_size825; ++$_i829) { - $elem814 = null; - $xfer += $input->readString($elem814); - $this->part_vals []= $elem814; + $elem830 = null; + $xfer += $input->readString($elem830); + $this->part_vals []= $elem830; } $xfer += $input->readListEnd(); } else { @@ -24472,9 +24956,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter815) + foreach ($this->part_vals as $iter831) { - $xfer += $output->writeString($iter815); + $xfer += $output->writeString($iter831); } } $output->writeListEnd(); @@ -24928,14 +25412,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size816 = 0; - $_etype819 = 0; - $xfer += $input->readListBegin($_etype819, $_size816); - for ($_i820 = 0; $_i820 < $_size816; ++$_i820) + $_size832 = 0; + $_etype835 = 0; + $xfer += $input->readListBegin($_etype835, $_size832); + for ($_i836 = 0; $_i836 < $_size832; ++$_i836) { - $elem821 = null; - $xfer += $input->readString($elem821); - $this->success []= $elem821; + $elem837 = null; + $xfer += $input->readString($elem837); + $this->success []= $elem837; } $xfer += $input->readListEnd(); } else { @@ -24971,9 +25455,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter822) + foreach ($this->success as $iter838) { - $xfer += $output->writeString($iter822); + $xfer += $output->writeString($iter838); } } $output->writeListEnd(); @@ -25133,17 +25617,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size823 = 0; - $_ktype824 = 0; - $_vtype825 = 0; - $xfer += $input->readMapBegin($_ktype824, $_vtype825, $_size823); - for ($_i827 = 0; $_i827 < $_size823; ++$_i827) + $_size839 = 0; + $_ktype840 = 0; + $_vtype841 = 0; + $xfer += $input->readMapBegin($_ktype840, $_vtype841, $_size839); + for ($_i843 = 0; $_i843 < $_size839; ++$_i843) { - $key828 = ''; - $val829 = ''; - $xfer += $input->readString($key828); - $xfer += $input->readString($val829); - $this->success[$key828] = $val829; + $key844 = ''; + $val845 = ''; + $xfer += $input->readString($key844); + $xfer += $input->readString($val845); + $this->success[$key844] = $val845; } $xfer += $input->readMapEnd(); } else { @@ -25179,10 +25663,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter830 => $viter831) + foreach ($this->success as $kiter846 => $viter847) { - $xfer += $output->writeString($kiter830); - $xfer += $output->writeString($viter831); + $xfer += $output->writeString($kiter846); + $xfer += $output->writeString($viter847); } } $output->writeMapEnd(); @@ -25302,17 +25786,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size832 = 0; - $_ktype833 = 0; - $_vtype834 = 0; - $xfer += $input->readMapBegin($_ktype833, $_vtype834, $_size832); - for ($_i836 = 0; $_i836 < $_size832; ++$_i836) + $_size848 = 0; + $_ktype849 = 0; + $_vtype850 = 0; + $xfer += $input->readMapBegin($_ktype849, $_vtype850, $_size848); + for ($_i852 = 0; $_i852 < $_size848; ++$_i852) { - $key837 = ''; - $val838 = ''; - $xfer += $input->readString($key837); - $xfer += $input->readString($val838); - $this->part_vals[$key837] = $val838; + $key853 = ''; + $val854 = ''; + $xfer += $input->readString($key853); + $xfer += $input->readString($val854); + $this->part_vals[$key853] = $val854; } $xfer += $input->readMapEnd(); } else { @@ -25357,10 +25841,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter839 => $viter840) + foreach ($this->part_vals as $kiter855 => $viter856) { - $xfer += $output->writeString($kiter839); - $xfer += $output->writeString($viter840); + $xfer += $output->writeString($kiter855); + $xfer += $output->writeString($viter856); } } $output->writeMapEnd(); @@ -25682,17 +26166,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size841 = 0; - $_ktype842 = 0; - $_vtype843 = 0; - $xfer += $input->readMapBegin($_ktype842, $_vtype843, $_size841); - for ($_i845 = 0; $_i845 < $_size841; ++$_i845) + $_size857 = 0; + $_ktype858 = 0; + $_vtype859 = 0; + $xfer += $input->readMapBegin($_ktype858, $_vtype859, $_size857); + for ($_i861 = 0; $_i861 < $_size857; ++$_i861) { - $key846 = ''; - $val847 = ''; - $xfer += $input->readString($key846); - $xfer += $input->readString($val847); - $this->part_vals[$key846] = $val847; + $key862 = ''; + $val863 = ''; + $xfer += $input->readString($key862); + $xfer += $input->readString($val863); + $this->part_vals[$key862] = $val863; } $xfer += $input->readMapEnd(); } else { @@ -25737,10 +26221,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter848 => $viter849) + foreach ($this->part_vals as $kiter864 => $viter865) { - $xfer += $output->writeString($kiter848); - $xfer += $output->writeString($viter849); + $xfer += $output->writeString($kiter864); + $xfer += $output->writeString($viter865); } } $output->writeMapEnd(); @@ -27214,15 +27698,15 @@ class ThriftHiveMetastore_get_indexes_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size850 = 0; - $_etype853 = 0; - $xfer += $input->readListBegin($_etype853, $_size850); - for ($_i854 = 0; $_i854 < $_size850; ++$_i854) + $_size866 = 0; + $_etype869 = 0; + $xfer += $input->readListBegin($_etype869, $_size866); + for ($_i870 = 0; $_i870 < $_size866; ++$_i870) { - $elem855 = null; - $elem855 = new \metastore\Index(); - $xfer += $elem855->read($input); - $this->success []= $elem855; + $elem871 = null; + $elem871 = new \metastore\Index(); + $xfer += $elem871->read($input); + $this->success []= $elem871; } $xfer += $input->readListEnd(); } else { @@ -27266,9 +27750,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter856) + foreach ($this->success as $iter872) { - $xfer += $iter856->write($output); + $xfer += $iter872->write($output); } } $output->writeListEnd(); @@ -27475,14 +27959,14 @@ class ThriftHiveMetastore_get_index_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size857 = 0; - $_etype860 = 0; - $xfer += $input->readListBegin($_etype860, $_size857); - for ($_i861 = 0; $_i861 < $_size857; ++$_i861) + $_size873 = 0; + $_etype876 = 0; + $xfer += $input->readListBegin($_etype876, $_size873); + for ($_i877 = 0; $_i877 < $_size873; ++$_i877) { - $elem862 = null; - $xfer += $input->readString($elem862); - $this->success []= $elem862; + $elem878 = null; + $xfer += $input->readString($elem878); + $this->success []= $elem878; } $xfer += $input->readListEnd(); } else { @@ -27518,9 +28002,9 @@ class ThriftHiveMetastore_get_index_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter863) + foreach ($this->success as $iter879) { - $xfer += $output->writeString($iter863); + $xfer += $output->writeString($iter879); } } $output->writeListEnd(); @@ -30994,14 +31478,14 @@ class ThriftHiveMetastore_get_functions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size864 = 0; - $_etype867 = 0; - $xfer += $input->readListBegin($_etype867, $_size864); - for ($_i868 = 0; $_i868 < $_size864; ++$_i868) + $_size880 = 0; + $_etype883 = 0; + $xfer += $input->readListBegin($_etype883, $_size880); + for ($_i884 = 0; $_i884 < $_size880; ++$_i884) { - $elem869 = null; - $xfer += $input->readString($elem869); - $this->success []= $elem869; + $elem885 = null; + $xfer += $input->readString($elem885); + $this->success []= $elem885; } $xfer += $input->readListEnd(); } else { @@ -31037,9 +31521,9 @@ class ThriftHiveMetastore_get_functions_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter870) + foreach ($this->success as $iter886) { - $xfer += $output->writeString($iter870); + $xfer += $output->writeString($iter886); } } $output->writeListEnd(); @@ -31908,14 +32392,14 @@ class ThriftHiveMetastore_get_role_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size871 = 0; - $_etype874 = 0; - $xfer += $input->readListBegin($_etype874, $_size871); - for ($_i875 = 0; $_i875 < $_size871; ++$_i875) + $_size887 = 0; + $_etype890 = 0; + $xfer += $input->readListBegin($_etype890, $_size887); + for ($_i891 = 0; $_i891 < $_size887; ++$_i891) { - $elem876 = null; - $xfer += $input->readString($elem876); - $this->success []= $elem876; + $elem892 = null; + $xfer += $input->readString($elem892); + $this->success []= $elem892; } $xfer += $input->readListEnd(); } else { @@ -31951,9 +32435,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter877) + foreach ($this->success as $iter893) { - $xfer += $output->writeString($iter877); + $xfer += $output->writeString($iter893); } } $output->writeListEnd(); @@ -32644,15 +33128,15 @@ class ThriftHiveMetastore_list_roles_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size878 = 0; - $_etype881 = 0; - $xfer += $input->readListBegin($_etype881, $_size878); - for ($_i882 = 0; $_i882 < $_size878; ++$_i882) + $_size894 = 0; + $_etype897 = 0; + $xfer += $input->readListBegin($_etype897, $_size894); + for ($_i898 = 0; $_i898 < $_size894; ++$_i898) { - $elem883 = null; - $elem883 = new \metastore\Role(); - $xfer += $elem883->read($input); - $this->success []= $elem883; + $elem899 = null; + $elem899 = new \metastore\Role(); + $xfer += $elem899->read($input); + $this->success []= $elem899; } $xfer += $input->readListEnd(); } else { @@ -32688,9 +33172,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter884) + foreach ($this->success as $iter900) { - $xfer += $iter884->write($output); + $xfer += $iter900->write($output); } } $output->writeListEnd(); @@ -33352,14 +33836,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size885 = 0; - $_etype888 = 0; - $xfer += $input->readListBegin($_etype888, $_size885); - for ($_i889 = 0; $_i889 < $_size885; ++$_i889) + $_size901 = 0; + $_etype904 = 0; + $xfer += $input->readListBegin($_etype904, $_size901); + for ($_i905 = 0; $_i905 < $_size901; ++$_i905) { - $elem890 = null; - $xfer += $input->readString($elem890); - $this->group_names []= $elem890; + $elem906 = null; + $xfer += $input->readString($elem906); + $this->group_names []= $elem906; } $xfer += $input->readListEnd(); } else { @@ -33400,9 +33884,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter891) + foreach ($this->group_names as $iter907) { - $xfer += $output->writeString($iter891); + $xfer += $output->writeString($iter907); } } $output->writeListEnd(); @@ -33710,15 +34194,15 @@ class ThriftHiveMetastore_list_privileges_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size892 = 0; - $_etype895 = 0; - $xfer += $input->readListBegin($_etype895, $_size892); - for ($_i896 = 0; $_i896 < $_size892; ++$_i896) + $_size908 = 0; + $_etype911 = 0; + $xfer += $input->readListBegin($_etype911, $_size908); + for ($_i912 = 0; $_i912 < $_size908; ++$_i912) { - $elem897 = null; - $elem897 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem897->read($input); - $this->success []= $elem897; + $elem913 = null; + $elem913 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem913->read($input); + $this->success []= $elem913; } $xfer += $input->readListEnd(); } else { @@ -33754,9 +34238,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter898) + foreach ($this->success as $iter914) { - $xfer += $iter898->write($output); + $xfer += $iter914->write($output); } } $output->writeListEnd(); @@ -34388,14 +34872,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size899 = 0; - $_etype902 = 0; - $xfer += $input->readListBegin($_etype902, $_size899); - for ($_i903 = 0; $_i903 < $_size899; ++$_i903) + $_size915 = 0; + $_etype918 = 0; + $xfer += $input->readListBegin($_etype918, $_size915); + for ($_i919 = 0; $_i919 < $_size915; ++$_i919) { - $elem904 = null; - $xfer += $input->readString($elem904); - $this->group_names []= $elem904; + $elem920 = null; + $xfer += $input->readString($elem920); + $this->group_names []= $elem920; } $xfer += $input->readListEnd(); } else { @@ -34428,9 +34912,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter905) + foreach ($this->group_names as $iter921) { - $xfer += $output->writeString($iter905); + $xfer += $output->writeString($iter921); } } $output->writeListEnd(); @@ -34506,14 +34990,14 @@ class ThriftHiveMetastore_set_ugi_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size906 = 0; - $_etype909 = 0; - $xfer += $input->readListBegin($_etype909, $_size906); - for ($_i910 = 0; $_i910 < $_size906; ++$_i910) + $_size922 = 0; + $_etype925 = 0; + $xfer += $input->readListBegin($_etype925, $_size922); + for ($_i926 = 0; $_i926 < $_size922; ++$_i926) { - $elem911 = null; - $xfer += $input->readString($elem911); - $this->success []= $elem911; + $elem927 = null; + $xfer += $input->readString($elem927); + $this->success []= $elem927; } $xfer += $input->readListEnd(); } else { @@ -34549,9 +35033,9 @@ class ThriftHiveMetastore_set_ugi_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter912) + foreach ($this->success as $iter928) { - $xfer += $output->writeString($iter912); + $xfer += $output->writeString($iter928); } } $output->writeListEnd(); diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 8dba17b..65ba10e 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -68,6 +68,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' DropPartitionsResult drop_partitions_req(DropPartitionsRequest req)') print(' Partition get_partition(string db_name, string tbl_name, part_vals)') print(' Partition exchange_partition( partitionSpecs, string source_db, string source_table_name, string dest_db, string dest_table_name)') + print(' exchange_partitions( partitionSpecs, string source_db, string source_table_name, string dest_db, string dest_table_name)') print(' Partition get_partition_with_auth(string db_name, string tbl_name, part_vals, string user_name, group_names)') print(' Partition get_partition_by_name(string db_name, string tbl_name, string part_name)') print(' get_partitions(string db_name, string tbl_name, i16 max_parts)') @@ -486,6 +487,12 @@ elif cmd == 'exchange_partition': sys.exit(1) pp.pprint(client.exchange_partition(eval(args[0]),args[1],args[2],args[3],args[4],)) +elif cmd == 'exchange_partitions': + if len(args) != 5: + print('exchange_partitions requires 5 args') + sys.exit(1) + pp.pprint(client.exchange_partitions(eval(args[0]),args[1],args[2],args[3],args[4],)) + elif cmd == 'get_partition_with_auth': if len(args) != 5: print('get_partition_with_auth requires 5 args') diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 59c7b94..9873810 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -387,6 +387,17 @@ def exchange_partition(self, partitionSpecs, source_db, source_table_name, dest_ """ pass + def exchange_partitions(self, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name): + """ + Parameters: + - partitionSpecs + - source_db + - source_table_name + - dest_db + - dest_table_name + """ + pass + def get_partition_with_auth(self, db_name, tbl_name, part_vals, user_name, group_names): """ Parameters: @@ -2728,6 +2739,53 @@ def recv_exchange_partition(self): raise result.o4 raise TApplicationException(TApplicationException.MISSING_RESULT, "exchange_partition failed: unknown result") + def exchange_partitions(self, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name): + """ + Parameters: + - partitionSpecs + - source_db + - source_table_name + - dest_db + - dest_table_name + """ + self.send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name) + return self.recv_exchange_partitions() + + def send_exchange_partitions(self, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name): + self._oprot.writeMessageBegin('exchange_partitions', TMessageType.CALL, self._seqid) + args = exchange_partitions_args() + args.partitionSpecs = partitionSpecs + args.source_db = source_db + args.source_table_name = source_table_name + args.dest_db = dest_db + args.dest_table_name = dest_table_name + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_exchange_partitions(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = exchange_partitions_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + if result.o4 is not None: + raise result.o4 + raise TApplicationException(TApplicationException.MISSING_RESULT, "exchange_partitions failed: unknown result") + def get_partition_with_auth(self, db_name, tbl_name, part_vals, user_name, group_names): """ Parameters: @@ -5817,6 +5875,7 @@ def __init__(self, handler): self._processMap["drop_partitions_req"] = Processor.process_drop_partitions_req self._processMap["get_partition"] = Processor.process_get_partition self._processMap["exchange_partition"] = Processor.process_exchange_partition + self._processMap["exchange_partitions"] = Processor.process_exchange_partitions self._processMap["get_partition_with_auth"] = Processor.process_get_partition_with_auth self._processMap["get_partition_by_name"] = Processor.process_get_partition_by_name self._processMap["get_partitions"] = Processor.process_get_partitions @@ -7069,6 +7128,37 @@ def process_exchange_partition(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_exchange_partitions(self, seqid, iprot, oprot): + args = exchange_partitions_args() + args.read(iprot) + iprot.readMessageEnd() + result = exchange_partitions_result() + try: + result.success = self._handler.exchange_partitions(args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except MetaException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except NoSuchObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except InvalidObjectException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except InvalidInputException as o4: + msg_type = TMessageType.REPLY + result.o4 = o4 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("exchange_partitions", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_partition_with_auth(self, seqid, iprot, oprot): args = get_partition_with_auth_args() args.read(iprot) @@ -17089,6 +17179,262 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class exchange_partitions_args: + """ + Attributes: + - partitionSpecs + - source_db + - source_table_name + - dest_db + - dest_table_name + """ + + thrift_spec = ( + None, # 0 + (1, TType.MAP, 'partitionSpecs', (TType.STRING,None,TType.STRING,None), None, ), # 1 + (2, TType.STRING, 'source_db', None, None, ), # 2 + (3, TType.STRING, 'source_table_name', None, None, ), # 3 + (4, TType.STRING, 'dest_db', None, None, ), # 4 + (5, TType.STRING, 'dest_table_name', None, None, ), # 5 + ) + + def __init__(self, partitionSpecs=None, source_db=None, source_table_name=None, dest_db=None, dest_table_name=None,): + self.partitionSpecs = partitionSpecs + self.source_db = source_db + self.source_table_name = source_table_name + self.dest_db = dest_db + self.dest_table_name = dest_table_name + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.MAP: + self.partitionSpecs = {} + (_ktype667, _vtype668, _size666 ) = iprot.readMapBegin() + for _i670 in xrange(_size666): + _key671 = iprot.readString() + _val672 = iprot.readString() + self.partitionSpecs[_key671] = _val672 + iprot.readMapEnd() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.source_db = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.source_table_name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRING: + self.dest_db = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.STRING: + self.dest_table_name = iprot.readString() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('exchange_partitions_args') + if self.partitionSpecs is not None: + oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) + oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) + for kiter673,viter674 in self.partitionSpecs.items(): + oprot.writeString(kiter673) + oprot.writeString(viter674) + oprot.writeMapEnd() + oprot.writeFieldEnd() + if self.source_db is not None: + oprot.writeFieldBegin('source_db', TType.STRING, 2) + oprot.writeString(self.source_db) + oprot.writeFieldEnd() + if self.source_table_name is not None: + oprot.writeFieldBegin('source_table_name', TType.STRING, 3) + oprot.writeString(self.source_table_name) + oprot.writeFieldEnd() + if self.dest_db is not None: + oprot.writeFieldBegin('dest_db', TType.STRING, 4) + oprot.writeString(self.dest_db) + oprot.writeFieldEnd() + if self.dest_table_name is not None: + oprot.writeFieldBegin('dest_table_name', TType.STRING, 5) + oprot.writeString(self.dest_table_name) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.partitionSpecs) + value = (value * 31) ^ hash(self.source_db) + value = (value * 31) ^ hash(self.source_table_name) + value = (value * 31) ^ hash(self.dest_db) + value = (value * 31) ^ hash(self.dest_table_name) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class exchange_partitions_result: + """ + Attributes: + - success + - o1 + - o2 + - o3 + - o4 + """ + + thrift_spec = ( + (0, TType.LIST, 'success', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 0 + (1, TType.STRUCT, 'o1', (MetaException, MetaException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 + ) + + def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): + self.success = success + self.o1 = o1 + self.o2 = o2 + self.o3 = o3 + self.o4 = o4 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 0: + if ftype == TType.LIST: + self.success = [] + (_etype678, _size675) = iprot.readListBegin() + for _i679 in xrange(_size675): + _elem680 = Partition() + _elem680.read(iprot) + self.success.append(_elem680) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = MetaException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = NoSuchObjectException() + self.o2.read(iprot) + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = InvalidObjectException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = InvalidInputException() + self.o4.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('exchange_partitions_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.LIST, 0) + oprot.writeListBegin(TType.STRUCT, len(self.success)) + for iter681 in self.success: + iter681.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) + oprot.writeFieldEnd() + if self.o3 is not None: + oprot.writeFieldBegin('o3', TType.STRUCT, 3) + self.o3.write(oprot) + oprot.writeFieldEnd() + if self.o4 is not None: + oprot.writeFieldBegin('o4', TType.STRUCT, 4) + self.o4.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + value = (value * 31) ^ hash(self.o4) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class get_partition_with_auth_args: """ Attributes: @@ -17137,10 +17483,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype669, _size666) = iprot.readListBegin() - for _i670 in xrange(_size666): - _elem671 = iprot.readString() - self.part_vals.append(_elem671) + (_etype685, _size682) = iprot.readListBegin() + for _i686 in xrange(_size682): + _elem687 = iprot.readString() + self.part_vals.append(_elem687) iprot.readListEnd() else: iprot.skip(ftype) @@ -17152,10 +17498,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype675, _size672) = iprot.readListBegin() - for _i676 in xrange(_size672): - _elem677 = iprot.readString() - self.group_names.append(_elem677) + (_etype691, _size688) = iprot.readListBegin() + for _i692 in xrange(_size688): + _elem693 = iprot.readString() + self.group_names.append(_elem693) iprot.readListEnd() else: iprot.skip(ftype) @@ -17180,8 +17526,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter678 in self.part_vals: - oprot.writeString(iter678) + for iter694 in self.part_vals: + oprot.writeString(iter694) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -17191,8 +17537,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter679 in self.group_names: - oprot.writeString(iter679) + for iter695 in self.group_names: + oprot.writeString(iter695) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17621,11 +17967,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype683, _size680) = iprot.readListBegin() - for _i684 in xrange(_size680): - _elem685 = Partition() - _elem685.read(iprot) - self.success.append(_elem685) + (_etype699, _size696) = iprot.readListBegin() + for _i700 in xrange(_size696): + _elem701 = Partition() + _elem701.read(iprot) + self.success.append(_elem701) iprot.readListEnd() else: iprot.skip(ftype) @@ -17654,8 +18000,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter686 in self.success: - iter686.write(oprot) + for iter702 in self.success: + iter702.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17749,10 +18095,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype690, _size687) = iprot.readListBegin() - for _i691 in xrange(_size687): - _elem692 = iprot.readString() - self.group_names.append(_elem692) + (_etype706, _size703) = iprot.readListBegin() + for _i707 in xrange(_size703): + _elem708 = iprot.readString() + self.group_names.append(_elem708) iprot.readListEnd() else: iprot.skip(ftype) @@ -17785,8 +18131,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter693 in self.group_names: - oprot.writeString(iter693) + for iter709 in self.group_names: + oprot.writeString(iter709) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17847,11 +18193,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype697, _size694) = iprot.readListBegin() - for _i698 in xrange(_size694): - _elem699 = Partition() - _elem699.read(iprot) - self.success.append(_elem699) + (_etype713, _size710) = iprot.readListBegin() + for _i714 in xrange(_size710): + _elem715 = Partition() + _elem715.read(iprot) + self.success.append(_elem715) iprot.readListEnd() else: iprot.skip(ftype) @@ -17880,8 +18226,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter700 in self.success: - iter700.write(oprot) + for iter716 in self.success: + iter716.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18039,11 +18385,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype704, _size701) = iprot.readListBegin() - for _i705 in xrange(_size701): - _elem706 = PartitionSpec() - _elem706.read(iprot) - self.success.append(_elem706) + (_etype720, _size717) = iprot.readListBegin() + for _i721 in xrange(_size717): + _elem722 = PartitionSpec() + _elem722.read(iprot) + self.success.append(_elem722) iprot.readListEnd() else: iprot.skip(ftype) @@ -18072,8 +18418,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter707 in self.success: - iter707.write(oprot) + for iter723 in self.success: + iter723.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18228,10 +18574,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype711, _size708) = iprot.readListBegin() - for _i712 in xrange(_size708): - _elem713 = iprot.readString() - self.success.append(_elem713) + (_etype727, _size724) = iprot.readListBegin() + for _i728 in xrange(_size724): + _elem729 = iprot.readString() + self.success.append(_elem729) iprot.readListEnd() else: iprot.skip(ftype) @@ -18254,8 +18600,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter714 in self.success: - oprot.writeString(iter714) + for iter730 in self.success: + oprot.writeString(iter730) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -18331,10 +18677,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype718, _size715) = iprot.readListBegin() - for _i719 in xrange(_size715): - _elem720 = iprot.readString() - self.part_vals.append(_elem720) + (_etype734, _size731) = iprot.readListBegin() + for _i735 in xrange(_size731): + _elem736 = iprot.readString() + self.part_vals.append(_elem736) iprot.readListEnd() else: iprot.skip(ftype) @@ -18364,8 +18710,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter721 in self.part_vals: - oprot.writeString(iter721) + for iter737 in self.part_vals: + oprot.writeString(iter737) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -18429,11 +18775,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype725, _size722) = iprot.readListBegin() - for _i726 in xrange(_size722): - _elem727 = Partition() - _elem727.read(iprot) - self.success.append(_elem727) + (_etype741, _size738) = iprot.readListBegin() + for _i742 in xrange(_size738): + _elem743 = Partition() + _elem743.read(iprot) + self.success.append(_elem743) iprot.readListEnd() else: iprot.skip(ftype) @@ -18462,8 +18808,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter728 in self.success: - iter728.write(oprot) + for iter744 in self.success: + iter744.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18550,10 +18896,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype732, _size729) = iprot.readListBegin() - for _i733 in xrange(_size729): - _elem734 = iprot.readString() - self.part_vals.append(_elem734) + (_etype748, _size745) = iprot.readListBegin() + for _i749 in xrange(_size745): + _elem750 = iprot.readString() + self.part_vals.append(_elem750) iprot.readListEnd() else: iprot.skip(ftype) @@ -18570,10 +18916,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype738, _size735) = iprot.readListBegin() - for _i739 in xrange(_size735): - _elem740 = iprot.readString() - self.group_names.append(_elem740) + (_etype754, _size751) = iprot.readListBegin() + for _i755 in xrange(_size751): + _elem756 = iprot.readString() + self.group_names.append(_elem756) iprot.readListEnd() else: iprot.skip(ftype) @@ -18598,8 +18944,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter741 in self.part_vals: - oprot.writeString(iter741) + for iter757 in self.part_vals: + oprot.writeString(iter757) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -18613,8 +18959,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter742 in self.group_names: - oprot.writeString(iter742) + for iter758 in self.group_names: + oprot.writeString(iter758) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18676,11 +19022,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype746, _size743) = iprot.readListBegin() - for _i747 in xrange(_size743): - _elem748 = Partition() - _elem748.read(iprot) - self.success.append(_elem748) + (_etype762, _size759) = iprot.readListBegin() + for _i763 in xrange(_size759): + _elem764 = Partition() + _elem764.read(iprot) + self.success.append(_elem764) iprot.readListEnd() else: iprot.skip(ftype) @@ -18709,8 +19055,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter749 in self.success: - iter749.write(oprot) + for iter765 in self.success: + iter765.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18791,10 +19137,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype753, _size750) = iprot.readListBegin() - for _i754 in xrange(_size750): - _elem755 = iprot.readString() - self.part_vals.append(_elem755) + (_etype769, _size766) = iprot.readListBegin() + for _i770 in xrange(_size766): + _elem771 = iprot.readString() + self.part_vals.append(_elem771) iprot.readListEnd() else: iprot.skip(ftype) @@ -18824,8 +19170,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter756 in self.part_vals: - oprot.writeString(iter756) + for iter772 in self.part_vals: + oprot.writeString(iter772) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -18889,10 +19235,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype760, _size757) = iprot.readListBegin() - for _i761 in xrange(_size757): - _elem762 = iprot.readString() - self.success.append(_elem762) + (_etype776, _size773) = iprot.readListBegin() + for _i777 in xrange(_size773): + _elem778 = iprot.readString() + self.success.append(_elem778) iprot.readListEnd() else: iprot.skip(ftype) @@ -18921,8 +19267,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter763 in self.success: - oprot.writeString(iter763) + for iter779 in self.success: + oprot.writeString(iter779) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19093,11 +19439,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype767, _size764) = iprot.readListBegin() - for _i768 in xrange(_size764): - _elem769 = Partition() - _elem769.read(iprot) - self.success.append(_elem769) + (_etype783, _size780) = iprot.readListBegin() + for _i784 in xrange(_size780): + _elem785 = Partition() + _elem785.read(iprot) + self.success.append(_elem785) iprot.readListEnd() else: iprot.skip(ftype) @@ -19126,8 +19472,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter770 in self.success: - iter770.write(oprot) + for iter786 in self.success: + iter786.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19298,11 +19644,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype774, _size771) = iprot.readListBegin() - for _i775 in xrange(_size771): - _elem776 = PartitionSpec() - _elem776.read(iprot) - self.success.append(_elem776) + (_etype790, _size787) = iprot.readListBegin() + for _i791 in xrange(_size787): + _elem792 = PartitionSpec() + _elem792.read(iprot) + self.success.append(_elem792) iprot.readListEnd() else: iprot.skip(ftype) @@ -19331,8 +19677,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter777 in self.success: - iter777.write(oprot) + for iter793 in self.success: + iter793.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19569,10 +19915,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype781, _size778) = iprot.readListBegin() - for _i782 in xrange(_size778): - _elem783 = iprot.readString() - self.names.append(_elem783) + (_etype797, _size794) = iprot.readListBegin() + for _i798 in xrange(_size794): + _elem799 = iprot.readString() + self.names.append(_elem799) iprot.readListEnd() else: iprot.skip(ftype) @@ -19597,8 +19943,8 @@ def write(self, oprot): if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter784 in self.names: - oprot.writeString(iter784) + for iter800 in self.names: + oprot.writeString(iter800) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -19657,11 +20003,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype788, _size785) = iprot.readListBegin() - for _i789 in xrange(_size785): - _elem790 = Partition() - _elem790.read(iprot) - self.success.append(_elem790) + (_etype804, _size801) = iprot.readListBegin() + for _i805 in xrange(_size801): + _elem806 = Partition() + _elem806.read(iprot) + self.success.append(_elem806) iprot.readListEnd() else: iprot.skip(ftype) @@ -19690,8 +20036,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter791 in self.success: - iter791.write(oprot) + for iter807 in self.success: + iter807.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19941,11 +20287,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype795, _size792) = iprot.readListBegin() - for _i796 in xrange(_size792): - _elem797 = Partition() - _elem797.read(iprot) - self.new_parts.append(_elem797) + (_etype811, _size808) = iprot.readListBegin() + for _i812 in xrange(_size808): + _elem813 = Partition() + _elem813.read(iprot) + self.new_parts.append(_elem813) iprot.readListEnd() else: iprot.skip(ftype) @@ -19970,8 +20316,8 @@ def write(self, oprot): if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter798 in self.new_parts: - iter798.write(oprot) + for iter814 in self.new_parts: + iter814.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20310,10 +20656,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype802, _size799) = iprot.readListBegin() - for _i803 in xrange(_size799): - _elem804 = iprot.readString() - self.part_vals.append(_elem804) + (_etype818, _size815) = iprot.readListBegin() + for _i819 in xrange(_size815): + _elem820 = iprot.readString() + self.part_vals.append(_elem820) iprot.readListEnd() else: iprot.skip(ftype) @@ -20344,8 +20690,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter805 in self.part_vals: - oprot.writeString(iter805) + for iter821 in self.part_vals: + oprot.writeString(iter821) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -20487,10 +20833,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype809, _size806) = iprot.readListBegin() - for _i810 in xrange(_size806): - _elem811 = iprot.readString() - self.part_vals.append(_elem811) + (_etype825, _size822) = iprot.readListBegin() + for _i826 in xrange(_size822): + _elem827 = iprot.readString() + self.part_vals.append(_elem827) iprot.readListEnd() else: iprot.skip(ftype) @@ -20512,8 +20858,8 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 1) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter812 in self.part_vals: - oprot.writeString(iter812) + for iter828 in self.part_vals: + oprot.writeString(iter828) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -20871,10 +21217,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype816, _size813) = iprot.readListBegin() - for _i817 in xrange(_size813): - _elem818 = iprot.readString() - self.success.append(_elem818) + (_etype832, _size829) = iprot.readListBegin() + for _i833 in xrange(_size829): + _elem834 = iprot.readString() + self.success.append(_elem834) iprot.readListEnd() else: iprot.skip(ftype) @@ -20897,8 +21243,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter819 in self.success: - oprot.writeString(iter819) + for iter835 in self.success: + oprot.writeString(iter835) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21022,11 +21368,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype821, _vtype822, _size820 ) = iprot.readMapBegin() - for _i824 in xrange(_size820): - _key825 = iprot.readString() - _val826 = iprot.readString() - self.success[_key825] = _val826 + (_ktype837, _vtype838, _size836 ) = iprot.readMapBegin() + for _i840 in xrange(_size836): + _key841 = iprot.readString() + _val842 = iprot.readString() + self.success[_key841] = _val842 iprot.readMapEnd() else: iprot.skip(ftype) @@ -21049,9 +21395,9 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success)) - for kiter827,viter828 in self.success.items(): - oprot.writeString(kiter827) - oprot.writeString(viter828) + for kiter843,viter844 in self.success.items(): + oprot.writeString(kiter843) + oprot.writeString(viter844) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21127,11 +21473,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype830, _vtype831, _size829 ) = iprot.readMapBegin() - for _i833 in xrange(_size829): - _key834 = iprot.readString() - _val835 = iprot.readString() - self.part_vals[_key834] = _val835 + (_ktype846, _vtype847, _size845 ) = iprot.readMapBegin() + for _i849 in xrange(_size845): + _key850 = iprot.readString() + _val851 = iprot.readString() + self.part_vals[_key850] = _val851 iprot.readMapEnd() else: iprot.skip(ftype) @@ -21161,9 +21507,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter836,viter837 in self.part_vals.items(): - oprot.writeString(kiter836) - oprot.writeString(viter837) + for kiter852,viter853 in self.part_vals.items(): + oprot.writeString(kiter852) + oprot.writeString(viter853) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -21377,11 +21723,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype839, _vtype840, _size838 ) = iprot.readMapBegin() - for _i842 in xrange(_size838): - _key843 = iprot.readString() - _val844 = iprot.readString() - self.part_vals[_key843] = _val844 + (_ktype855, _vtype856, _size854 ) = iprot.readMapBegin() + for _i858 in xrange(_size854): + _key859 = iprot.readString() + _val860 = iprot.readString() + self.part_vals[_key859] = _val860 iprot.readMapEnd() else: iprot.skip(ftype) @@ -21411,9 +21757,9 @@ def write(self, oprot): if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.MAP, 3) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.part_vals)) - for kiter845,viter846 in self.part_vals.items(): - oprot.writeString(kiter845) - oprot.writeString(viter846) + for kiter861,viter862 in self.part_vals.items(): + oprot.writeString(kiter861) + oprot.writeString(viter862) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -22468,11 +22814,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype850, _size847) = iprot.readListBegin() - for _i851 in xrange(_size847): - _elem852 = Index() - _elem852.read(iprot) - self.success.append(_elem852) + (_etype866, _size863) = iprot.readListBegin() + for _i867 in xrange(_size863): + _elem868 = Index() + _elem868.read(iprot) + self.success.append(_elem868) iprot.readListEnd() else: iprot.skip(ftype) @@ -22501,8 +22847,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter853 in self.success: - iter853.write(oprot) + for iter869 in self.success: + iter869.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -22657,10 +23003,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype857, _size854) = iprot.readListBegin() - for _i858 in xrange(_size854): - _elem859 = iprot.readString() - self.success.append(_elem859) + (_etype873, _size870) = iprot.readListBegin() + for _i874 in xrange(_size870): + _elem875 = iprot.readString() + self.success.append(_elem875) iprot.readListEnd() else: iprot.skip(ftype) @@ -22683,8 +23029,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter860 in self.success: - oprot.writeString(iter860) + for iter876 in self.success: + oprot.writeString(iter876) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -25232,10 +25578,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype864, _size861) = iprot.readListBegin() - for _i865 in xrange(_size861): - _elem866 = iprot.readString() - self.success.append(_elem866) + (_etype880, _size877) = iprot.readListBegin() + for _i881 in xrange(_size877): + _elem882 = iprot.readString() + self.success.append(_elem882) iprot.readListEnd() else: iprot.skip(ftype) @@ -25258,8 +25604,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter867 in self.success: - oprot.writeString(iter867) + for iter883 in self.success: + oprot.writeString(iter883) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25947,10 +26293,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype871, _size868) = iprot.readListBegin() - for _i872 in xrange(_size868): - _elem873 = iprot.readString() - self.success.append(_elem873) + (_etype887, _size884) = iprot.readListBegin() + for _i888 in xrange(_size884): + _elem889 = iprot.readString() + self.success.append(_elem889) iprot.readListEnd() else: iprot.skip(ftype) @@ -25973,8 +26319,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter874 in self.success: - oprot.writeString(iter874) + for iter890 in self.success: + oprot.writeString(iter890) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26488,11 +26834,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype878, _size875) = iprot.readListBegin() - for _i879 in xrange(_size875): - _elem880 = Role() - _elem880.read(iprot) - self.success.append(_elem880) + (_etype894, _size891) = iprot.readListBegin() + for _i895 in xrange(_size891): + _elem896 = Role() + _elem896.read(iprot) + self.success.append(_elem896) iprot.readListEnd() else: iprot.skip(ftype) @@ -26515,8 +26861,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter881 in self.success: - iter881.write(oprot) + for iter897 in self.success: + iter897.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -27025,10 +27371,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype885, _size882) = iprot.readListBegin() - for _i886 in xrange(_size882): - _elem887 = iprot.readString() - self.group_names.append(_elem887) + (_etype901, _size898) = iprot.readListBegin() + for _i902 in xrange(_size898): + _elem903 = iprot.readString() + self.group_names.append(_elem903) iprot.readListEnd() else: iprot.skip(ftype) @@ -27053,8 +27399,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter888 in self.group_names: - oprot.writeString(iter888) + for iter904 in self.group_names: + oprot.writeString(iter904) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -27281,11 +27627,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype892, _size889) = iprot.readListBegin() - for _i893 in xrange(_size889): - _elem894 = HiveObjectPrivilege() - _elem894.read(iprot) - self.success.append(_elem894) + (_etype908, _size905) = iprot.readListBegin() + for _i909 in xrange(_size905): + _elem910 = HiveObjectPrivilege() + _elem910.read(iprot) + self.success.append(_elem910) iprot.readListEnd() else: iprot.skip(ftype) @@ -27308,8 +27654,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter895 in self.success: - iter895.write(oprot) + for iter911 in self.success: + iter911.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -27807,10 +28153,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype899, _size896) = iprot.readListBegin() - for _i900 in xrange(_size896): - _elem901 = iprot.readString() - self.group_names.append(_elem901) + (_etype915, _size912) = iprot.readListBegin() + for _i916 in xrange(_size912): + _elem917 = iprot.readString() + self.group_names.append(_elem917) iprot.readListEnd() else: iprot.skip(ftype) @@ -27831,8 +28177,8 @@ def write(self, oprot): if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter902 in self.group_names: - oprot.writeString(iter902) + for iter918 in self.group_names: + oprot.writeString(iter918) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -27887,10 +28233,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype906, _size903) = iprot.readListBegin() - for _i907 in xrange(_size903): - _elem908 = iprot.readString() - self.success.append(_elem908) + (_etype922, _size919) = iprot.readListBegin() + for _i923 in xrange(_size919): + _elem924 = iprot.readString() + self.success.append(_elem924) iprot.readListEnd() else: iprot.skip(ftype) @@ -27913,8 +28259,8 @@ def write(self, oprot): if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter909 in self.success: - oprot.writeString(iter909) + for iter925 in self.success: + oprot.writeString(iter925) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 7b93158..c613e4b 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -766,6 +766,25 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'exchange_partition failed: unknown result') end + def exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name) + send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name) + return recv_exchange_partitions() + end + + def send_exchange_partitions(partitionSpecs, source_db, source_table_name, dest_db, dest_table_name) + send_message('exchange_partitions', Exchange_partitions_args, :partitionSpecs => partitionSpecs, :source_db => source_db, :source_table_name => source_table_name, :dest_db => dest_db, :dest_table_name => dest_table_name) + end + + def recv_exchange_partitions() + result = receive_message(Exchange_partitions_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + raise result.o4 unless result.o4.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'exchange_partitions failed: unknown result') + end + def get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names) send_get_partition_with_auth(db_name, tbl_name, part_vals, user_name, group_names) return recv_get_partition_with_auth() @@ -2775,6 +2794,23 @@ module ThriftHiveMetastore write_result(result, oprot, 'exchange_partition', seqid) end + def process_exchange_partitions(seqid, iprot, oprot) + args = read_args(iprot, Exchange_partitions_args) + result = Exchange_partitions_result.new() + begin + result.success = @handler.exchange_partitions(args.partitionSpecs, args.source_db, args.source_table_name, args.dest_db, args.dest_table_name) + rescue ::MetaException => o1 + result.o1 = o1 + rescue ::NoSuchObjectException => o2 + result.o2 = o2 + rescue ::InvalidObjectException => o3 + result.o3 = o3 + rescue ::InvalidInputException => o4 + result.o4 = o4 + end + write_result(result, oprot, 'exchange_partitions', seqid) + end + def process_get_partition_with_auth(seqid, iprot, oprot) args = read_args(iprot, Get_partition_with_auth_args) result = Get_partition_with_auth_result.new() @@ -5509,6 +5545,54 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Exchange_partitions_args + include ::Thrift::Struct, ::Thrift::Struct_Union + PARTITIONSPECS = 1 + SOURCE_DB = 2 + SOURCE_TABLE_NAME = 3 + DEST_DB = 4 + DEST_TABLE_NAME = 5 + + FIELDS = { + PARTITIONSPECS => {:type => ::Thrift::Types::MAP, :name => 'partitionSpecs', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}, + SOURCE_DB => {:type => ::Thrift::Types::STRING, :name => 'source_db'}, + SOURCE_TABLE_NAME => {:type => ::Thrift::Types::STRING, :name => 'source_table_name'}, + DEST_DB => {:type => ::Thrift::Types::STRING, :name => 'dest_db'}, + DEST_TABLE_NAME => {:type => ::Thrift::Types::STRING, :name => 'dest_table_name'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Exchange_partitions_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + O4 = 4 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Partition}}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::NoSuchObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::InvalidObjectException}, + O4 => {:type => ::Thrift::Types::STRUCT, :name => 'o4', :class => ::InvalidInputException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Get_partition_with_auth_args include ::Thrift::Struct, ::Thrift::Struct_Union DB_NAME = 1 diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index cf2e25b..45a13f3 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -2467,6 +2467,15 @@ public Partition exchange_partition(Map partitionSpecs, String sourceDbName, String sourceTableName, String destDbName, String destTableName) throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException, TException { + exchange_partitions(partitionSpecs, sourceDbName, sourceTableName, destDbName, destTableName); + return new Partition(); + } + + @Override + public List exchange_partitions(Map partitionSpecs, + String sourceDbName, String sourceTableName, String destDbName, + String destTableName) throws MetaException, NoSuchObjectException, + InvalidObjectException, InvalidInputException, TException { boolean success = false; boolean pathCreated = false; RawStore ms = getMS(); @@ -2501,6 +2510,7 @@ public Partition exchange_partition(Map partitionSpecs, Path destPath = new Path(destinationTable.getSd().getLocation(), Warehouse.makePartName(partitionKeysPresent, partValsPresent)); try { + List destPartitions = new ArrayList(); for (Partition partition: partitionsToExchange) { Partition destPartition = new Partition(partition); destPartition.setDbName(destDbName); @@ -2509,6 +2519,7 @@ public Partition exchange_partition(Map partitionSpecs, Warehouse.makePartName(destinationTable.getPartitionKeys(), partition.getValues())); destPartition.getSd().setLocation(destPartitionPath.toString()); ms.addPartition(destPartition); + destPartitions.add(destPartition); ms.dropPartition(partition.getDbName(), sourceTable.getTableName(), partition.getValues()); } @@ -2524,6 +2535,7 @@ public Partition exchange_partition(Map partitionSpecs, */ pathCreated = wh.renameDir(sourcePath, destPath); success = ms.commitTransaction(); + return destPartitions; } finally { if (!success || !pathCreated) { ms.rollbackTransaction(); @@ -2532,7 +2544,6 @@ public Partition exchange_partition(Map partitionSpecs, } } } - return new Partition(); } private boolean drop_partition_common(RawStore ms, String db_name, String tbl_name, diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java index 3960f5d..f86ec45 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -659,6 +659,22 @@ public Partition exchange_partition(Map partitionSpecs, destDb, destinationTableName); } + /** + * Exchange the partitions between two tables + * @param partitionSpecs partitions specs of the parent partition to be exchanged + * @param destDb the db of the destination table + * @param destinationTableName the destination table name + @ @return new partitions after exchanging + */ + @Override + public List exchange_partitions(Map partitionSpecs, + String sourceDb, String sourceTable, String destDb, + String destinationTableName) throws MetaException, + NoSuchObjectException, InvalidObjectException, TException { + return client.exchange_partitions(partitionSpecs, sourceDb, sourceTable, + destDb, destinationTableName); + } + @Override public void validatePartitionNameCharacters(List partVals) throws TException, MetaException { diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java index f3a23f5..024d18a 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -453,6 +453,22 @@ Partition exchange_partition(Map partitionSpecs, InvalidObjectException, TException; /** + * With the one partitionSpecs to exchange, multiple partitions could be exchanged. + * e.g., year=2015/month/day, exchanging partition year=2015 results to all the partitions + * belonging to it exchanged. This function returns the list of affected partitions. + * @param partitionSpecs + * @param sourceDb + * @param sourceTable + * @param destdb + * @param destTableName + * @return the list of the new partitions + */ + List exchange_partitions(Map partitionSpecs, + String sourceDb, String sourceTable, String destdb, + String destTableName) throws MetaException, NoSuchObjectException, + InvalidObjectException, TException; + + /** * @param dbName * @param tblName * @param name - partition name i.e. 'ds=2010-02-03/ts=2010-02-03 18%3A16%3A01' diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java index dcac9ca..cd8512d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java @@ -4189,9 +4189,20 @@ private int exchangeTablePartition(Hive db, Map partitionSpecs = exchangePartition.getPartitionSpecs(); Table destTable = exchangePartition.getDestinationTable(); Table sourceTable = exchangePartition.getSourceTable(); - db.exchangeTablePartitions(partitionSpecs, sourceTable.getDbName(), + List partitions = + db.exchangeTablePartitions(partitionSpecs, sourceTable.getDbName(), sourceTable.getTableName(),destTable.getDbName(), destTable.getTableName()); + + for(Partition partition : partitions) { + // Reuse the partition specs from dest partition since they should be the same + work.getOutputs().add(new WriteEntity(new Partition(sourceTable, partition.getSpec(), null), + WriteEntity.WriteType.DELETE)); + + work.getOutputs().add(new WriteEntity(new Partition(destTable, partition.getSpec(), null), + WriteEntity.WriteType.INSERT)); + } + return 0; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java index cef297a..dbc7170 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java @@ -2085,7 +2085,7 @@ public boolean dropPartition(String dbName, String tableName, List partV } List tParts = getMSC().dropPartitions( dbName, tblName, partExprs, dropOptions); - return convertFromMetastore(tbl, tParts, null); + return convertFromMetastore(tbl, tParts); } catch (NoSuchObjectException e) { throw new HiveException("Partition or table doesn't exist.", e); } catch (Exception e) { @@ -2329,22 +2329,20 @@ public boolean dropPartition(String dbName, String tableName, List partV List tParts = getMSC().listPartitionsByFilter( tbl.getDbName(), tbl.getTableName(), filter, (short)-1); - return convertFromMetastore(tbl, tParts, null); + return convertFromMetastore(tbl, tParts); } private static List convertFromMetastore(Table tbl, - List src, - List dest) throws HiveException { - if (src == null) { - return dest; + List partitions) throws HiveException { + if (partitions == null) { + return new ArrayList(); } - if (dest == null) { - dest = new ArrayList(src.size()); - } - for (org.apache.hadoop.hive.metastore.api.Partition tPart : src) { - dest.add(new Partition(tbl, tPart)); + + List results = new ArrayList(partitions.size()); + for (org.apache.hadoop.hive.metastore.api.Partition tPart : partitions) { + results.add(new Partition(tbl, tPart)); } - return dest; + return results; } /** @@ -2364,7 +2362,7 @@ public boolean getPartitionsByExpr(Table tbl, ExprNodeGenericFuncDesc expr, Hive new ArrayList(); boolean hasUnknownParts = getMSC().listPartitionsByExpr(tbl.getDbName(), tbl.getTableName(), exprBytes, defaultPartitionName, (short)-1, msParts); - convertFromMetastore(tbl, msParts, result); + result.addAll(convertFromMetastore(tbl, msParts)); return hasUnknownParts; } @@ -3001,12 +2999,15 @@ public static boolean isHadoop1() { return ShimLoader.getMajorVersion().startsWith("0.20"); } - public void exchangeTablePartitions(Map partitionSpecs, + public List exchangeTablePartitions(Map partitionSpecs, String sourceDb, String sourceTable, String destDb, String destinationTableName) throws HiveException { try { - getMSC().exchange_partition(partitionSpecs, sourceDb, sourceTable, destDb, + List partitions = + getMSC().exchange_partitions(partitionSpecs, sourceDb, sourceTable, destDb, destinationTableName); + + return convertFromMetastore(getTable(destDb, destinationTableName), partitions); } catch (Exception ex) { LOG.error(StringUtils.stringifyException(ex)); throw new HiveException(ex); diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java index b4546e1..eea2fcc 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java @@ -19,6 +19,7 @@ package org.apache.hadoop.hive.ql.parse; import com.google.common.collect.Lists; + import org.antlr.runtime.tree.CommonTree; import org.antlr.runtime.tree.Tree; import org.slf4j.Logger; @@ -49,6 +50,7 @@ import org.apache.hadoop.hive.ql.exec.Utilities; import org.apache.hadoop.hive.ql.hooks.ReadEntity; import org.apache.hadoop.hive.ql.hooks.WriteEntity; +import org.apache.hadoop.hive.ql.hooks.WriteEntity.WriteType; import org.apache.hadoop.hive.ql.index.HiveIndex; import org.apache.hadoop.hive.ql.index.HiveIndex.IndexType; import org.apache.hadoop.hive.ql.index.HiveIndexHandler; @@ -718,6 +720,9 @@ private void analyzeExchangePartition(String[] qualified, ASTNode ast) throws Se new AlterTableExchangePartition(sourceTable, destTable, partSpecs); rootTasks.add(TaskFactory.get(new DDLWork(getInputs(), getOutputs(), alterTableExchangePartition), conf)); + + outputs.add(new WriteEntity(sourceTable, WriteType.DDL_SHARED)); + outputs.add(new WriteEntity(destTable, WriteType.DDL_SHARED)); } /** diff --git a/ql/src/test/results/clientnegative/exchange_partition.q.out b/ql/src/test/results/clientnegative/exchange_partition.q.out index 8622615..f5e332a 100644 --- a/ql/src/test/results/clientnegative/exchange_partition.q.out +++ b/ql/src/test/results/clientnegative/exchange_partition.q.out @@ -51,4 +51,6 @@ POSTHOOK: Input: default@ex_table2 part=part1 PREHOOK: query: ALTER TABLE ex_table1 EXCHANGE PARTITION (part='part1') WITH TABLE ex_table2 PREHOOK: type: ALTERTABLE_EXCHANGEPARTITION +PREHOOK: Output: default@ex_table1 +PREHOOK: Output: default@ex_table2 FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:Got exception: java.io.IOException Cannot rename the source path. The destination path already exists.) diff --git a/ql/src/test/results/clientpositive/exchange_partition.q.out b/ql/src/test/results/clientpositive/exchange_partition.q.out index 5b21eaf..9316341 100644 --- a/ql/src/test/results/clientpositive/exchange_partition.q.out +++ b/ql/src/test/results/clientpositive/exchange_partition.q.out @@ -60,8 +60,14 @@ POSTHOOK: Input: ex2@exchange_part_test2 ds=2013-04-05 PREHOOK: query: ALTER TABLE ex1.exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05') WITH TABLE ex2.exchange_part_test2 PREHOOK: type: ALTERTABLE_EXCHANGEPARTITION +PREHOOK: Output: ex1@exchange_part_test1 +PREHOOK: Output: ex2@exchange_part_test2 POSTHOOK: query: ALTER TABLE ex1.exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05') WITH TABLE ex2.exchange_part_test2 POSTHOOK: type: ALTERTABLE_EXCHANGEPARTITION +POSTHOOK: Output: ex1@exchange_part_test1 +POSTHOOK: Output: ex1@exchange_part_test1@ds=2013-04-05 +POSTHOOK: Output: ex2@exchange_part_test2 +POSTHOOK: Output: ex2@exchange_part_test2@ds=2013-04-05 PREHOOK: query: SHOW PARTITIONS ex1.exchange_part_test1 PREHOOK: type: SHOWPARTITIONS PREHOOK: Input: ex1@exchange_part_test1 diff --git a/ql/src/test/results/clientpositive/exchange_partition2.q.out b/ql/src/test/results/clientpositive/exchange_partition2.q.out index 8c7c583..05121d8 100644 --- a/ql/src/test/results/clientpositive/exchange_partition2.q.out +++ b/ql/src/test/results/clientpositive/exchange_partition2.q.out @@ -48,8 +48,14 @@ POSTHOOK: Input: default@exchange_part_test2 ds=2013-04-05/hr=1 PREHOOK: query: ALTER TABLE exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05', hr='1') WITH TABLE exchange_part_test2 PREHOOK: type: ALTERTABLE_EXCHANGEPARTITION +PREHOOK: Output: default@exchange_part_test1 +PREHOOK: Output: default@exchange_part_test2 POSTHOOK: query: ALTER TABLE exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05', hr='1') WITH TABLE exchange_part_test2 POSTHOOK: type: ALTERTABLE_EXCHANGEPARTITION +POSTHOOK: Output: default@exchange_part_test1 +POSTHOOK: Output: default@exchange_part_test1@ds=2013-04-05/hr=1 +POSTHOOK: Output: default@exchange_part_test2 +POSTHOOK: Output: default@exchange_part_test2@ds=2013-04-05/hr=1 PREHOOK: query: SHOW PARTITIONS exchange_part_test1 PREHOOK: type: SHOWPARTITIONS PREHOOK: Input: default@exchange_part_test1 diff --git a/ql/src/test/results/clientpositive/exchange_partition3.q.out b/ql/src/test/results/clientpositive/exchange_partition3.q.out index 3815861..014be7c 100644 --- a/ql/src/test/results/clientpositive/exchange_partition3.q.out +++ b/ql/src/test/results/clientpositive/exchange_partition3.q.out @@ -65,9 +65,17 @@ ds=2013-04-05/hr=2 PREHOOK: query: -- This will exchange both partitions hr=1 and hr=2 ALTER TABLE exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05') WITH TABLE exchange_part_test2 PREHOOK: type: ALTERTABLE_EXCHANGEPARTITION +PREHOOK: Output: default@exchange_part_test1 +PREHOOK: Output: default@exchange_part_test2 POSTHOOK: query: -- This will exchange both partitions hr=1 and hr=2 ALTER TABLE exchange_part_test1 EXCHANGE PARTITION (ds='2013-04-05') WITH TABLE exchange_part_test2 POSTHOOK: type: ALTERTABLE_EXCHANGEPARTITION +POSTHOOK: Output: default@exchange_part_test1 +POSTHOOK: Output: default@exchange_part_test1@ds=2013-04-05/hr=1 +POSTHOOK: Output: default@exchange_part_test1@ds=2013-04-05/hr=2 +POSTHOOK: Output: default@exchange_part_test2 +POSTHOOK: Output: default@exchange_part_test2@ds=2013-04-05/hr=1 +POSTHOOK: Output: default@exchange_part_test2@ds=2013-04-05/hr=2 PREHOOK: query: SHOW PARTITIONS exchange_part_test1 PREHOOK: type: SHOWPARTITIONS PREHOOK: Input: default@exchange_part_test1