diff --git a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java index 47e94ea..c612708 100644 --- a/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java +++ b/itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java @@ -135,6 +135,7 @@ public void testPartition() throws Exception { partitionTester(client, hiveConf); } + @SuppressWarnings("unchecked") public static void partitionTester(HiveMetaStoreClient client, HiveConf hiveConf) throws Exception { try { @@ -423,7 +424,57 @@ public static void partitionTester(HiveMetaStoreClient client, HiveConf hiveConf Arrays.asList(mvals1.get(0)), Arrays.asList(mpart1,mpart2,mpart3,mpart5)); - //// end add_partitions tests + // end add_partitions tests + + // test drop_partitions + try { + client.dropPartitions(dbName, tblName, + Arrays.asList(mvals1, mvals2, mvals3, mvals4, mvals5), + false); + } catch (Exception e) { + savedException = e; + } finally { + assertNotNull(savedException); + } + + client.dropPartitions(dbName, tblName, + Arrays.asList(mvals1, mvals2), + false); + + verifyPartitionsPublished(client, dbName, tblName, + Arrays.asList(mvals1.get(0)), + Arrays.asList(mpart3, mpart5)); + + // end drop_partitions + + // test add_drop_partitions + List mvals6 = makeVals("2008-07-04 14:13:12", "14646"); + List mvals7 = makeVals("2008-07-04 14:13:12", "14647"); + + Partition mpart6 = makePartitionObject(dbName, tblName, mvals6, tbl, "/mpart6"); + Partition mpart7 = makePartitionObject(dbName, tblName, mvals7, tbl, "/mpart7"); + + client.addDropPartitions(dbName, tblName, + new ArrayList(), Arrays.asList(mvals3), false); + + verifyPartitionsPublished(client, dbName, tblName, + Arrays.asList(mvals1.get(0)), + Arrays.asList(mpart5)); + + client.addDropPartitions(dbName, tblName, + Arrays.asList(mpart6, mpart7), Arrays.asList(mvals5), false); + + if(isThriftClient) { + // do DDL time munging if thrift mode + adjust(client, mpart6, dbName, tblName); + adjust(client, mpart7, dbName, tblName); + } + + verifyPartitionsPublished(client, dbName, tblName, + Arrays.asList(mvals1.get(0)), + Arrays.asList(mpart6, mpart7)); + + // end add_drop_partitions client.dropTable(dbName, tblName); diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index eef1b80..284016d 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -763,6 +763,11 @@ service ThriftHiveMetastore extends fb303.FacebookService Partition append_partition_by_name_with_environment_context(1:string db_name, 2:string tbl_name, 3:string part_name, 4:EnvironmentContext environment_context) throws (1:InvalidObjectException o1, 2:AlreadyExistsException o2, 3:MetaException o3) + bool add_drop_partitions(1:string db_name, 2:string tbl_name, 3:list add_parts, + 4:list> drop_part_vals, 5:bool deleteData) + throws(1:InvalidObjectException o1, 2:AlreadyExistsException o2, + 3:NoSuchObjectException o3, 4:MetaException o4) + bool drop_partitions(1:string db_name, 2:string tbl_name, 3:list> part_vals, 4:bool deleteData) bool drop_partition(1:string db_name, 2:string tbl_name, 3:list part_vals, 4:bool deleteData) throws(1:NoSuchObjectException o1, 2:MetaException o2) bool drop_partition_with_environment_context(1:string db_name, 2:string tbl_name, diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 9567874..9016315 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -7268,6 +7268,662 @@ uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_p return xfer; } +uint32_t ThriftHiveMetastore_add_drop_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->add_parts.clear(); + uint32_t _size490; + ::apache::thrift::protocol::TType _etype493; + xfer += iprot->readListBegin(_etype493, _size490); + this->add_parts.resize(_size490); + uint32_t _i494; + for (_i494 = 0; _i494 < _size490; ++_i494) + { + xfer += this->add_parts[_i494].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.add_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->drop_part_vals.clear(); + uint32_t _size495; + ::apache::thrift::protocol::TType _etype498; + xfer += iprot->readListBegin(_etype498, _size495); + this->drop_part_vals.resize(_size495); + uint32_t _i499; + for (_i499 = 0; _i499 < _size495; ++_i499) + { + { + this->drop_part_vals[_i499].clear(); + uint32_t _size500; + ::apache::thrift::protocol::TType _etype503; + xfer += iprot->readListBegin(_etype503, _size500); + this->drop_part_vals[_i499].resize(_size500); + uint32_t _i504; + for (_i504 = 0; _i504 < _size500; ++_i504) + { + xfer += iprot->readString(this->drop_part_vals[_i499][_i504]); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readListEnd(); + } + this->__isset.drop_part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_drop_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_drop_partitions_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("add_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->add_parts.size())); + std::vector ::const_iterator _iter505; + for (_iter505 = this->add_parts.begin(); _iter505 != this->add_parts.end(); ++_iter505) + { + xfer += (*_iter505).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("drop_part_vals", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->drop_part_vals.size())); + std::vector > ::const_iterator _iter506; + for (_iter506 = this->drop_part_vals.begin(); _iter506 != this->drop_part_vals.end(); ++_iter506) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter506).size())); + std::vector ::const_iterator _iter507; + for (_iter507 = (*_iter506).begin(); _iter507 != (*_iter506).end(); ++_iter507) + { + xfer += oprot->writeString((*_iter507)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_add_drop_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_drop_partitions_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("add_parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->add_parts)).size())); + std::vector ::const_iterator _iter508; + for (_iter508 = (*(this->add_parts)).begin(); _iter508 != (*(this->add_parts)).end(); ++_iter508) + { + xfer += (*_iter508).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("drop_part_vals", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast((*(this->drop_part_vals)).size())); + std::vector > ::const_iterator _iter509; + for (_iter509 = (*(this->drop_part_vals)).begin(); _iter509 != (*(this->drop_part_vals)).end(); ++_iter509) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter509).size())); + std::vector ::const_iterator _iter510; + for (_iter510 = (*_iter509).begin(); _iter510 != (*_iter509).end(); ++_iter510) + { + xfer += oprot->writeString((*_iter510)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_add_drop_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + 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_add_drop_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_drop_partitions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } 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; +} + +uint32_t ThriftHiveMetastore_add_drop_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + 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_drop_partitions_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tbl_name); + this->__isset.tbl_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->part_vals.clear(); + uint32_t _size511; + ::apache::thrift::protocol::TType _etype514; + xfer += iprot->readListBegin(_etype514, _size511); + this->part_vals.resize(_size511); + uint32_t _i515; + for (_i515 = 0; _i515 < _size511; ++_i515) + { + { + this->part_vals[_i515].clear(); + uint32_t _size516; + ::apache::thrift::protocol::TType _etype519; + xfer += iprot->readListBegin(_etype519, _size516); + this->part_vals[_i515].resize(_size516); + uint32_t _i520; + for (_i520 = 0; _i520 < _size516; ++_i520) + { + xfer += iprot->readString(this->part_vals[_i515][_i520]); + } + xfer += iprot->readListEnd(); + } + } + xfer += iprot->readListEnd(); + } + this->__isset.part_vals = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tbl_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast(this->part_vals.size())); + std::vector > ::const_iterator _iter521; + for (_iter521 = this->part_vals.begin(); _iter521 != this->part_vals.end(); ++_iter521) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter521).size())); + std::vector ::const_iterator _iter522; + for (_iter522 = (*_iter521).begin(); _iter522 != (*_iter521).end(); ++_iter522) + { + xfer += oprot->writeString((*_iter522)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tbl_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast((*(this->part_vals)).size())); + std::vector > ::const_iterator _iter523; + for (_iter523 = (*(this->part_vals)).begin(); _iter523 != (*(this->part_vals)).end(); ++_iter523) + { + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*_iter523).size())); + std::vector ::const_iterator _iter524; + for (_iter524 = (*_iter523).begin(); _iter524 != (*_iter523).end(); ++_iter524) + { + xfer += oprot->writeString((*_iter524)); + } + xfer += oprot->writeListEnd(); + } + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partitions_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_partitions_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; @@ -7308,14 +7964,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size490; - ::apache::thrift::protocol::TType _etype493; - xfer += iprot->readListBegin(_etype493, _size490); - this->part_vals.resize(_size490); - uint32_t _i494; - for (_i494 = 0; _i494 < _size490; ++_i494) + uint32_t _size525; + ::apache::thrift::protocol::TType _etype528; + xfer += iprot->readListBegin(_etype528, _size525); + this->part_vals.resize(_size525); + uint32_t _i529; + for (_i529 = 0; _i529 < _size525; ++_i529) { - xfer += iprot->readString(this->part_vals[_i494]); + xfer += iprot->readString(this->part_vals[_i529]); } xfer += iprot->readListEnd(); } @@ -7359,10 +8015,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc 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 _iter495; - for (_iter495 = this->part_vals.begin(); _iter495 != this->part_vals.end(); ++_iter495) + std::vector ::const_iterator _iter530; + for (_iter530 = this->part_vals.begin(); _iter530 != this->part_vals.end(); ++_iter530) { - xfer += oprot->writeString((*_iter495)); + xfer += oprot->writeString((*_iter530)); } xfer += oprot->writeListEnd(); } @@ -7392,10 +8048,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto 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 _iter496; - for (_iter496 = (*(this->part_vals)).begin(); _iter496 != (*(this->part_vals)).end(); ++_iter496) + std::vector ::const_iterator _iter531; + for (_iter531 = (*(this->part_vals)).begin(); _iter531 != (*(this->part_vals)).end(); ++_iter531) { - xfer += oprot->writeString((*_iter496)); + xfer += oprot->writeString((*_iter531)); } xfer += oprot->writeListEnd(); } @@ -7586,14 +8242,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size497; - ::apache::thrift::protocol::TType _etype500; - xfer += iprot->readListBegin(_etype500, _size497); - this->part_vals.resize(_size497); - uint32_t _i501; - for (_i501 = 0; _i501 < _size497; ++_i501) + uint32_t _size532; + ::apache::thrift::protocol::TType _etype535; + xfer += iprot->readListBegin(_etype535, _size532); + this->part_vals.resize(_size532); + uint32_t _i536; + for (_i536 = 0; _i536 < _size532; ++_i536) { - xfer += iprot->readString(this->part_vals[_i501]); + xfer += iprot->readString(this->part_vals[_i536]); } xfer += iprot->readListEnd(); } @@ -7645,10 +8301,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write 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 _iter502; - for (_iter502 = this->part_vals.begin(); _iter502 != this->part_vals.end(); ++_iter502) + std::vector ::const_iterator _iter537; + for (_iter537 = this->part_vals.begin(); _iter537 != this->part_vals.end(); ++_iter537) { - xfer += oprot->writeString((*_iter502)); + xfer += oprot->writeString((*_iter537)); } xfer += oprot->writeListEnd(); } @@ -7682,10 +8338,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ 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 _iter503; - for (_iter503 = (*(this->part_vals)).begin(); _iter503 != (*(this->part_vals)).end(); ++_iter503) + std::vector ::const_iterator _iter538; + for (_iter538 = (*(this->part_vals)).begin(); _iter538 != (*(this->part_vals)).end(); ++_iter538) { - xfer += oprot->writeString((*_iter503)); + xfer += oprot->writeString((*_iter538)); } xfer += oprot->writeListEnd(); } @@ -8598,14 +9254,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size504; - ::apache::thrift::protocol::TType _etype507; - xfer += iprot->readListBegin(_etype507, _size504); - this->part_vals.resize(_size504); - uint32_t _i508; - for (_i508 = 0; _i508 < _size504; ++_i508) + uint32_t _size539; + ::apache::thrift::protocol::TType _etype542; + xfer += iprot->readListBegin(_etype542, _size539); + this->part_vals.resize(_size539); + uint32_t _i543; + for (_i543 = 0; _i543 < _size539; ++_i543) { - xfer += iprot->readString(this->part_vals[_i508]); + xfer += iprot->readString(this->part_vals[_i543]); } xfer += iprot->readListEnd(); } @@ -8641,10 +9297,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco 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 _iter509; - for (_iter509 = this->part_vals.begin(); _iter509 != this->part_vals.end(); ++_iter509) + std::vector ::const_iterator _iter544; + for (_iter544 = this->part_vals.begin(); _iter544 != this->part_vals.end(); ++_iter544) { - xfer += oprot->writeString((*_iter509)); + xfer += oprot->writeString((*_iter544)); } xfer += oprot->writeListEnd(); } @@ -8670,10 +9326,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc 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 _iter510; - for (_iter510 = (*(this->part_vals)).begin(); _iter510 != (*(this->part_vals)).end(); ++_iter510) + std::vector ::const_iterator _iter545; + for (_iter545 = (*(this->part_vals)).begin(); _iter545 != (*(this->part_vals)).end(); ++_iter545) { - xfer += oprot->writeString((*_iter510)); + xfer += oprot->writeString((*_iter545)); } xfer += oprot->writeListEnd(); } @@ -8844,17 +9500,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size511; - ::apache::thrift::protocol::TType _ktype512; - ::apache::thrift::protocol::TType _vtype513; - xfer += iprot->readMapBegin(_ktype512, _vtype513, _size511); - uint32_t _i515; - for (_i515 = 0; _i515 < _size511; ++_i515) + uint32_t _size546; + ::apache::thrift::protocol::TType _ktype547; + ::apache::thrift::protocol::TType _vtype548; + xfer += iprot->readMapBegin(_ktype547, _vtype548, _size546); + uint32_t _i550; + for (_i550 = 0; _i550 < _size546; ++_i550) { - std::string _key516; - xfer += iprot->readString(_key516); - std::string& _val517 = this->partitionSpecs[_key516]; - xfer += iprot->readString(_val517); + std::string _key551; + xfer += iprot->readString(_key551); + std::string& _val552 = this->partitionSpecs[_key551]; + xfer += iprot->readString(_val552); } xfer += iprot->readMapEnd(); } @@ -8914,11 +9570,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr 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 _iter518; - for (_iter518 = this->partitionSpecs.begin(); _iter518 != this->partitionSpecs.end(); ++_iter518) + std::map ::const_iterator _iter553; + for (_iter553 = this->partitionSpecs.begin(); _iter553 != this->partitionSpecs.end(); ++_iter553) { - xfer += oprot->writeString(_iter518->first); - xfer += oprot->writeString(_iter518->second); + xfer += oprot->writeString(_iter553->first); + xfer += oprot->writeString(_iter553->second); } xfer += oprot->writeMapEnd(); } @@ -8952,11 +9608,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p 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 _iter519; - for (_iter519 = (*(this->partitionSpecs)).begin(); _iter519 != (*(this->partitionSpecs)).end(); ++_iter519) + std::map ::const_iterator _iter554; + for (_iter554 = (*(this->partitionSpecs)).begin(); _iter554 != (*(this->partitionSpecs)).end(); ++_iter554) { - xfer += oprot->writeString(_iter519->first); - xfer += oprot->writeString(_iter519->second); + xfer += oprot->writeString(_iter554->first); + xfer += oprot->writeString(_iter554->second); } xfer += oprot->writeMapEnd(); } @@ -9199,14 +9855,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 _size520; - ::apache::thrift::protocol::TType _etype523; - xfer += iprot->readListBegin(_etype523, _size520); - this->part_vals.resize(_size520); - uint32_t _i524; - for (_i524 = 0; _i524 < _size520; ++_i524) + uint32_t _size555; + ::apache::thrift::protocol::TType _etype558; + xfer += iprot->readListBegin(_etype558, _size555); + this->part_vals.resize(_size555); + uint32_t _i559; + for (_i559 = 0; _i559 < _size555; ++_i559) { - xfer += iprot->readString(this->part_vals[_i524]); + xfer += iprot->readString(this->part_vals[_i559]); } xfer += iprot->readListEnd(); } @@ -9227,14 +9883,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 _size525; - ::apache::thrift::protocol::TType _etype528; - xfer += iprot->readListBegin(_etype528, _size525); - this->group_names.resize(_size525); - uint32_t _i529; - for (_i529 = 0; _i529 < _size525; ++_i529) + uint32_t _size560; + ::apache::thrift::protocol::TType _etype563; + xfer += iprot->readListBegin(_etype563, _size560); + this->group_names.resize(_size560); + uint32_t _i564; + for (_i564 = 0; _i564 < _size560; ++_i564) { - xfer += iprot->readString(this->group_names[_i529]); + xfer += iprot->readString(this->group_names[_i564]); } xfer += iprot->readListEnd(); } @@ -9270,10 +9926,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 _iter530; - for (_iter530 = this->part_vals.begin(); _iter530 != this->part_vals.end(); ++_iter530) + std::vector ::const_iterator _iter565; + for (_iter565 = this->part_vals.begin(); _iter565 != this->part_vals.end(); ++_iter565) { - xfer += oprot->writeString((*_iter530)); + xfer += oprot->writeString((*_iter565)); } xfer += oprot->writeListEnd(); } @@ -9286,10 +9942,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 _iter531; - for (_iter531 = this->group_names.begin(); _iter531 != this->group_names.end(); ++_iter531) + std::vector ::const_iterator _iter566; + for (_iter566 = this->group_names.begin(); _iter566 != this->group_names.end(); ++_iter566) { - xfer += oprot->writeString((*_iter531)); + xfer += oprot->writeString((*_iter566)); } xfer += oprot->writeListEnd(); } @@ -9315,10 +9971,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 _iter532; - for (_iter532 = (*(this->part_vals)).begin(); _iter532 != (*(this->part_vals)).end(); ++_iter532) + std::vector ::const_iterator _iter567; + for (_iter567 = (*(this->part_vals)).begin(); _iter567 != (*(this->part_vals)).end(); ++_iter567) { - xfer += oprot->writeString((*_iter532)); + xfer += oprot->writeString((*_iter567)); } xfer += oprot->writeListEnd(); } @@ -9331,10 +9987,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 _iter533; - for (_iter533 = (*(this->group_names)).begin(); _iter533 != (*(this->group_names)).end(); ++_iter533) + std::vector ::const_iterator _iter568; + for (_iter568 = (*(this->group_names)).begin(); _iter568 != (*(this->group_names)).end(); ++_iter568) { - xfer += oprot->writeString((*_iter533)); + xfer += oprot->writeString((*_iter568)); } xfer += oprot->writeListEnd(); } @@ -9837,14 +10493,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size534; - ::apache::thrift::protocol::TType _etype537; - xfer += iprot->readListBegin(_etype537, _size534); - this->success.resize(_size534); - uint32_t _i538; - for (_i538 = 0; _i538 < _size534; ++_i538) + uint32_t _size569; + ::apache::thrift::protocol::TType _etype572; + xfer += iprot->readListBegin(_etype572, _size569); + this->success.resize(_size569); + uint32_t _i573; + for (_i573 = 0; _i573 < _size569; ++_i573) { - xfer += this->success[_i538].read(iprot); + xfer += this->success[_i573].read(iprot); } xfer += iprot->readListEnd(); } @@ -9891,10 +10547,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 _iter539; - for (_iter539 = this->success.begin(); _iter539 != this->success.end(); ++_iter539) + std::vector ::const_iterator _iter574; + for (_iter574 = this->success.begin(); _iter574 != this->success.end(); ++_iter574) { - xfer += (*_iter539).write(oprot); + xfer += (*_iter574).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9937,14 +10593,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size540; - ::apache::thrift::protocol::TType _etype543; - xfer += iprot->readListBegin(_etype543, _size540); - (*(this->success)).resize(_size540); - uint32_t _i544; - for (_i544 = 0; _i544 < _size540; ++_i544) + uint32_t _size575; + ::apache::thrift::protocol::TType _etype578; + xfer += iprot->readListBegin(_etype578, _size575); + (*(this->success)).resize(_size575); + uint32_t _i579; + for (_i579 = 0; _i579 < _size575; ++_i579) { - xfer += (*(this->success))[_i544].read(iprot); + xfer += (*(this->success))[_i579].read(iprot); } xfer += iprot->readListEnd(); } @@ -10037,14 +10693,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 _size545; - ::apache::thrift::protocol::TType _etype548; - xfer += iprot->readListBegin(_etype548, _size545); - this->group_names.resize(_size545); - uint32_t _i549; - for (_i549 = 0; _i549 < _size545; ++_i549) + uint32_t _size580; + ::apache::thrift::protocol::TType _etype583; + xfer += iprot->readListBegin(_etype583, _size580); + this->group_names.resize(_size580); + uint32_t _i584; + for (_i584 = 0; _i584 < _size580; ++_i584) { - xfer += iprot->readString(this->group_names[_i549]); + xfer += iprot->readString(this->group_names[_i584]); } xfer += iprot->readListEnd(); } @@ -10088,10 +10744,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 _iter550; - for (_iter550 = this->group_names.begin(); _iter550 != this->group_names.end(); ++_iter550) + std::vector ::const_iterator _iter585; + for (_iter585 = this->group_names.begin(); _iter585 != this->group_names.end(); ++_iter585) { - xfer += oprot->writeString((*_iter550)); + xfer += oprot->writeString((*_iter585)); } xfer += oprot->writeListEnd(); } @@ -10125,10 +10781,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 _iter551; - for (_iter551 = (*(this->group_names)).begin(); _iter551 != (*(this->group_names)).end(); ++_iter551) + std::vector ::const_iterator _iter586; + for (_iter586 = (*(this->group_names)).begin(); _iter586 != (*(this->group_names)).end(); ++_iter586) { - xfer += oprot->writeString((*_iter551)); + xfer += oprot->writeString((*_iter586)); } xfer += oprot->writeListEnd(); } @@ -10163,14 +10819,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size552; - ::apache::thrift::protocol::TType _etype555; - xfer += iprot->readListBegin(_etype555, _size552); - this->success.resize(_size552); - uint32_t _i556; - for (_i556 = 0; _i556 < _size552; ++_i556) + uint32_t _size587; + ::apache::thrift::protocol::TType _etype590; + xfer += iprot->readListBegin(_etype590, _size587); + this->success.resize(_size587); + uint32_t _i591; + for (_i591 = 0; _i591 < _size587; ++_i591) { - xfer += this->success[_i556].read(iprot); + xfer += this->success[_i591].read(iprot); } xfer += iprot->readListEnd(); } @@ -10217,10 +10873,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 _iter557; - for (_iter557 = this->success.begin(); _iter557 != this->success.end(); ++_iter557) + std::vector ::const_iterator _iter592; + for (_iter592 = this->success.begin(); _iter592 != this->success.end(); ++_iter592) { - xfer += (*_iter557).write(oprot); + xfer += (*_iter592).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10263,14 +10919,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size558; - ::apache::thrift::protocol::TType _etype561; - xfer += iprot->readListBegin(_etype561, _size558); - (*(this->success)).resize(_size558); - uint32_t _i562; - for (_i562 = 0; _i562 < _size558; ++_i562) + uint32_t _size593; + ::apache::thrift::protocol::TType _etype596; + xfer += iprot->readListBegin(_etype596, _size593); + (*(this->success)).resize(_size593); + uint32_t _i597; + for (_i597 = 0; _i597 < _size593; ++_i597) { - xfer += (*(this->success))[_i562].read(iprot); + xfer += (*(this->success))[_i597].read(iprot); } xfer += iprot->readListEnd(); } @@ -10429,14 +11085,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size563; - ::apache::thrift::protocol::TType _etype566; - xfer += iprot->readListBegin(_etype566, _size563); - this->success.resize(_size563); - uint32_t _i567; - for (_i567 = 0; _i567 < _size563; ++_i567) + uint32_t _size598; + ::apache::thrift::protocol::TType _etype601; + xfer += iprot->readListBegin(_etype601, _size598); + this->success.resize(_size598); + uint32_t _i602; + for (_i602 = 0; _i602 < _size598; ++_i602) { - xfer += iprot->readString(this->success[_i567]); + xfer += iprot->readString(this->success[_i602]); } xfer += iprot->readListEnd(); } @@ -10475,10 +11131,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 _iter568; - for (_iter568 = this->success.begin(); _iter568 != this->success.end(); ++_iter568) + std::vector ::const_iterator _iter603; + for (_iter603 = this->success.begin(); _iter603 != this->success.end(); ++_iter603) { - xfer += oprot->writeString((*_iter568)); + xfer += oprot->writeString((*_iter603)); } xfer += oprot->writeListEnd(); } @@ -10517,14 +11173,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size569; - ::apache::thrift::protocol::TType _etype572; - xfer += iprot->readListBegin(_etype572, _size569); - (*(this->success)).resize(_size569); - uint32_t _i573; - for (_i573 = 0; _i573 < _size569; ++_i573) + uint32_t _size604; + ::apache::thrift::protocol::TType _etype607; + xfer += iprot->readListBegin(_etype607, _size604); + (*(this->success)).resize(_size604); + uint32_t _i608; + for (_i608 = 0; _i608 < _size604; ++_i608) { - xfer += iprot->readString((*(this->success))[_i573]); + xfer += iprot->readString((*(this->success))[_i608]); } xfer += iprot->readListEnd(); } @@ -10593,14 +11249,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 _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - this->part_vals.resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + uint32_t _size609; + ::apache::thrift::protocol::TType _etype612; + xfer += iprot->readListBegin(_etype612, _size609); + this->part_vals.resize(_size609); + uint32_t _i613; + for (_i613 = 0; _i613 < _size609; ++_i613) { - xfer += iprot->readString(this->part_vals[_i578]); + xfer += iprot->readString(this->part_vals[_i613]); } xfer += iprot->readListEnd(); } @@ -10644,10 +11300,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 _iter579; - for (_iter579 = this->part_vals.begin(); _iter579 != this->part_vals.end(); ++_iter579) + std::vector ::const_iterator _iter614; + for (_iter614 = this->part_vals.begin(); _iter614 != this->part_vals.end(); ++_iter614) { - xfer += oprot->writeString((*_iter579)); + xfer += oprot->writeString((*_iter614)); } xfer += oprot->writeListEnd(); } @@ -10677,10 +11333,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 _iter580; - for (_iter580 = (*(this->part_vals)).begin(); _iter580 != (*(this->part_vals)).end(); ++_iter580) + std::vector ::const_iterator _iter615; + for (_iter615 = (*(this->part_vals)).begin(); _iter615 != (*(this->part_vals)).end(); ++_iter615) { - xfer += oprot->writeString((*_iter580)); + xfer += oprot->writeString((*_iter615)); } xfer += oprot->writeListEnd(); } @@ -10719,14 +11375,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size581; - ::apache::thrift::protocol::TType _etype584; - xfer += iprot->readListBegin(_etype584, _size581); - this->success.resize(_size581); - uint32_t _i585; - for (_i585 = 0; _i585 < _size581; ++_i585) + uint32_t _size616; + ::apache::thrift::protocol::TType _etype619; + xfer += iprot->readListBegin(_etype619, _size616); + this->success.resize(_size616); + uint32_t _i620; + for (_i620 = 0; _i620 < _size616; ++_i620) { - xfer += this->success[_i585].read(iprot); + xfer += this->success[_i620].read(iprot); } xfer += iprot->readListEnd(); } @@ -10773,10 +11429,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 _iter586; - for (_iter586 = this->success.begin(); _iter586 != this->success.end(); ++_iter586) + std::vector ::const_iterator _iter621; + for (_iter621 = this->success.begin(); _iter621 != this->success.end(); ++_iter621) { - xfer += (*_iter586).write(oprot); + xfer += (*_iter621).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10819,14 +11475,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size587; - ::apache::thrift::protocol::TType _etype590; - xfer += iprot->readListBegin(_etype590, _size587); - (*(this->success)).resize(_size587); - uint32_t _i591; - for (_i591 = 0; _i591 < _size587; ++_i591) + uint32_t _size622; + ::apache::thrift::protocol::TType _etype625; + xfer += iprot->readListBegin(_etype625, _size622); + (*(this->success)).resize(_size622); + uint32_t _i626; + for (_i626 = 0; _i626 < _size622; ++_i626) { - xfer += (*(this->success))[_i591].read(iprot); + xfer += (*(this->success))[_i626].read(iprot); } xfer += iprot->readListEnd(); } @@ -10903,14 +11559,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 _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readListBegin(_etype595, _size592); - this->part_vals.resize(_size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + uint32_t _size627; + ::apache::thrift::protocol::TType _etype630; + xfer += iprot->readListBegin(_etype630, _size627); + this->part_vals.resize(_size627); + uint32_t _i631; + for (_i631 = 0; _i631 < _size627; ++_i631) { - xfer += iprot->readString(this->part_vals[_i596]); + xfer += iprot->readString(this->part_vals[_i631]); } xfer += iprot->readListEnd(); } @@ -10939,14 +11595,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 _size597; - ::apache::thrift::protocol::TType _etype600; - xfer += iprot->readListBegin(_etype600, _size597); - this->group_names.resize(_size597); - uint32_t _i601; - for (_i601 = 0; _i601 < _size597; ++_i601) + uint32_t _size632; + ::apache::thrift::protocol::TType _etype635; + xfer += iprot->readListBegin(_etype635, _size632); + this->group_names.resize(_size632); + uint32_t _i636; + for (_i636 = 0; _i636 < _size632; ++_i636) { - xfer += iprot->readString(this->group_names[_i601]); + xfer += iprot->readString(this->group_names[_i636]); } xfer += iprot->readListEnd(); } @@ -10982,10 +11638,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 _iter602; - for (_iter602 = this->part_vals.begin(); _iter602 != this->part_vals.end(); ++_iter602) + std::vector ::const_iterator _iter637; + for (_iter637 = this->part_vals.begin(); _iter637 != this->part_vals.end(); ++_iter637) { - xfer += oprot->writeString((*_iter602)); + xfer += oprot->writeString((*_iter637)); } xfer += oprot->writeListEnd(); } @@ -11002,10 +11658,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 _iter603; - for (_iter603 = this->group_names.begin(); _iter603 != this->group_names.end(); ++_iter603) + std::vector ::const_iterator _iter638; + for (_iter638 = this->group_names.begin(); _iter638 != this->group_names.end(); ++_iter638) { - xfer += oprot->writeString((*_iter603)); + xfer += oprot->writeString((*_iter638)); } xfer += oprot->writeListEnd(); } @@ -11031,10 +11687,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 _iter604; - for (_iter604 = (*(this->part_vals)).begin(); _iter604 != (*(this->part_vals)).end(); ++_iter604) + std::vector ::const_iterator _iter639; + for (_iter639 = (*(this->part_vals)).begin(); _iter639 != (*(this->part_vals)).end(); ++_iter639) { - xfer += oprot->writeString((*_iter604)); + xfer += oprot->writeString((*_iter639)); } xfer += oprot->writeListEnd(); } @@ -11051,10 +11707,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 _iter605; - for (_iter605 = (*(this->group_names)).begin(); _iter605 != (*(this->group_names)).end(); ++_iter605) + std::vector ::const_iterator _iter640; + for (_iter640 = (*(this->group_names)).begin(); _iter640 != (*(this->group_names)).end(); ++_iter640) { - xfer += oprot->writeString((*_iter605)); + xfer += oprot->writeString((*_iter640)); } xfer += oprot->writeListEnd(); } @@ -11089,14 +11745,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size606; - ::apache::thrift::protocol::TType _etype609; - xfer += iprot->readListBegin(_etype609, _size606); - this->success.resize(_size606); - uint32_t _i610; - for (_i610 = 0; _i610 < _size606; ++_i610) + uint32_t _size641; + ::apache::thrift::protocol::TType _etype644; + xfer += iprot->readListBegin(_etype644, _size641); + this->success.resize(_size641); + uint32_t _i645; + for (_i645 = 0; _i645 < _size641; ++_i645) { - xfer += this->success[_i610].read(iprot); + xfer += this->success[_i645].read(iprot); } xfer += iprot->readListEnd(); } @@ -11143,10 +11799,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 _iter611; - for (_iter611 = this->success.begin(); _iter611 != this->success.end(); ++_iter611) + std::vector ::const_iterator _iter646; + for (_iter646 = this->success.begin(); _iter646 != this->success.end(); ++_iter646) { - xfer += (*_iter611).write(oprot); + xfer += (*_iter646).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11189,14 +11845,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size612; - ::apache::thrift::protocol::TType _etype615; - xfer += iprot->readListBegin(_etype615, _size612); - (*(this->success)).resize(_size612); - uint32_t _i616; - for (_i616 = 0; _i616 < _size612; ++_i616) + uint32_t _size647; + ::apache::thrift::protocol::TType _etype650; + xfer += iprot->readListBegin(_etype650, _size647); + (*(this->success)).resize(_size647); + uint32_t _i651; + for (_i651 = 0; _i651 < _size647; ++_i651) { - xfer += (*(this->success))[_i616].read(iprot); + xfer += (*(this->success))[_i651].read(iprot); } xfer += iprot->readListEnd(); } @@ -11273,14 +11929,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 _size617; - ::apache::thrift::protocol::TType _etype620; - xfer += iprot->readListBegin(_etype620, _size617); - this->part_vals.resize(_size617); - uint32_t _i621; - for (_i621 = 0; _i621 < _size617; ++_i621) + uint32_t _size652; + ::apache::thrift::protocol::TType _etype655; + xfer += iprot->readListBegin(_etype655, _size652); + this->part_vals.resize(_size652); + uint32_t _i656; + for (_i656 = 0; _i656 < _size652; ++_i656) { - xfer += iprot->readString(this->part_vals[_i621]); + xfer += iprot->readString(this->part_vals[_i656]); } xfer += iprot->readListEnd(); } @@ -11324,10 +11980,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 _iter622; - for (_iter622 = this->part_vals.begin(); _iter622 != this->part_vals.end(); ++_iter622) + std::vector ::const_iterator _iter657; + for (_iter657 = this->part_vals.begin(); _iter657 != this->part_vals.end(); ++_iter657) { - xfer += oprot->writeString((*_iter622)); + xfer += oprot->writeString((*_iter657)); } xfer += oprot->writeListEnd(); } @@ -11357,10 +12013,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 _iter623; - for (_iter623 = (*(this->part_vals)).begin(); _iter623 != (*(this->part_vals)).end(); ++_iter623) + std::vector ::const_iterator _iter658; + for (_iter658 = (*(this->part_vals)).begin(); _iter658 != (*(this->part_vals)).end(); ++_iter658) { - xfer += oprot->writeString((*_iter623)); + xfer += oprot->writeString((*_iter658)); } xfer += oprot->writeListEnd(); } @@ -11399,14 +12055,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size624; - ::apache::thrift::protocol::TType _etype627; - xfer += iprot->readListBegin(_etype627, _size624); - this->success.resize(_size624); - uint32_t _i628; - for (_i628 = 0; _i628 < _size624; ++_i628) + uint32_t _size659; + ::apache::thrift::protocol::TType _etype662; + xfer += iprot->readListBegin(_etype662, _size659); + this->success.resize(_size659); + uint32_t _i663; + for (_i663 = 0; _i663 < _size659; ++_i663) { - xfer += iprot->readString(this->success[_i628]); + xfer += iprot->readString(this->success[_i663]); } xfer += iprot->readListEnd(); } @@ -11453,10 +12109,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 _iter629; - for (_iter629 = this->success.begin(); _iter629 != this->success.end(); ++_iter629) + std::vector ::const_iterator _iter664; + for (_iter664 = this->success.begin(); _iter664 != this->success.end(); ++_iter664) { - xfer += oprot->writeString((*_iter629)); + xfer += oprot->writeString((*_iter664)); } xfer += oprot->writeListEnd(); } @@ -11499,14 +12155,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size630; - ::apache::thrift::protocol::TType _etype633; - xfer += iprot->readListBegin(_etype633, _size630); - (*(this->success)).resize(_size630); - uint32_t _i634; - for (_i634 = 0; _i634 < _size630; ++_i634) + uint32_t _size665; + ::apache::thrift::protocol::TType _etype668; + xfer += iprot->readListBegin(_etype668, _size665); + (*(this->success)).resize(_size665); + uint32_t _i669; + for (_i669 = 0; _i669 < _size665; ++_i669) { - xfer += iprot->readString((*(this->success))[_i634]); + xfer += iprot->readString((*(this->success))[_i669]); } xfer += iprot->readListEnd(); } @@ -11681,14 +12337,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size635; - ::apache::thrift::protocol::TType _etype638; - xfer += iprot->readListBegin(_etype638, _size635); - this->success.resize(_size635); - uint32_t _i639; - for (_i639 = 0; _i639 < _size635; ++_i639) + uint32_t _size670; + ::apache::thrift::protocol::TType _etype673; + xfer += iprot->readListBegin(_etype673, _size670); + this->success.resize(_size670); + uint32_t _i674; + for (_i674 = 0; _i674 < _size670; ++_i674) { - xfer += this->success[_i639].read(iprot); + xfer += this->success[_i674].read(iprot); } xfer += iprot->readListEnd(); } @@ -11735,10 +12391,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 _iter640; - for (_iter640 = this->success.begin(); _iter640 != this->success.end(); ++_iter640) + std::vector ::const_iterator _iter675; + for (_iter675 = this->success.begin(); _iter675 != this->success.end(); ++_iter675) { - xfer += (*_iter640).write(oprot); + xfer += (*_iter675).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11781,14 +12437,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - (*(this->success)).resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size676; + ::apache::thrift::protocol::TType _etype679; + xfer += iprot->readListBegin(_etype679, _size676); + (*(this->success)).resize(_size676); + uint32_t _i680; + for (_i680 = 0; _i680 < _size676; ++_i680) { - xfer += (*(this->success))[_i645].read(iprot); + xfer += (*(this->success))[_i680].read(iprot); } xfer += iprot->readListEnd(); } @@ -12067,14 +12723,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size646; - ::apache::thrift::protocol::TType _etype649; - xfer += iprot->readListBegin(_etype649, _size646); - this->names.resize(_size646); - uint32_t _i650; - for (_i650 = 0; _i650 < _size646; ++_i650) + uint32_t _size681; + ::apache::thrift::protocol::TType _etype684; + xfer += iprot->readListBegin(_etype684, _size681); + this->names.resize(_size681); + uint32_t _i685; + for (_i685 = 0; _i685 < _size681; ++_i685) { - xfer += iprot->readString(this->names[_i650]); + xfer += iprot->readString(this->names[_i685]); } xfer += iprot->readListEnd(); } @@ -12110,10 +12766,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 _iter651; - for (_iter651 = this->names.begin(); _iter651 != this->names.end(); ++_iter651) + std::vector ::const_iterator _iter686; + for (_iter686 = this->names.begin(); _iter686 != this->names.end(); ++_iter686) { - xfer += oprot->writeString((*_iter651)); + xfer += oprot->writeString((*_iter686)); } xfer += oprot->writeListEnd(); } @@ -12139,10 +12795,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 _iter652; - for (_iter652 = (*(this->names)).begin(); _iter652 != (*(this->names)).end(); ++_iter652) + std::vector ::const_iterator _iter687; + for (_iter687 = (*(this->names)).begin(); _iter687 != (*(this->names)).end(); ++_iter687) { - xfer += oprot->writeString((*_iter652)); + xfer += oprot->writeString((*_iter687)); } xfer += oprot->writeListEnd(); } @@ -12177,14 +12833,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size653; - ::apache::thrift::protocol::TType _etype656; - xfer += iprot->readListBegin(_etype656, _size653); - this->success.resize(_size653); - uint32_t _i657; - for (_i657 = 0; _i657 < _size653; ++_i657) + uint32_t _size688; + ::apache::thrift::protocol::TType _etype691; + xfer += iprot->readListBegin(_etype691, _size688); + this->success.resize(_size688); + uint32_t _i692; + for (_i692 = 0; _i692 < _size688; ++_i692) { - xfer += this->success[_i657].read(iprot); + xfer += this->success[_i692].read(iprot); } xfer += iprot->readListEnd(); } @@ -12231,10 +12887,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 _iter658; - for (_iter658 = this->success.begin(); _iter658 != this->success.end(); ++_iter658) + std::vector ::const_iterator _iter693; + for (_iter693 = this->success.begin(); _iter693 != this->success.end(); ++_iter693) { - xfer += (*_iter658).write(oprot); + xfer += (*_iter693).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12277,14 +12933,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size659; - ::apache::thrift::protocol::TType _etype662; - xfer += iprot->readListBegin(_etype662, _size659); - (*(this->success)).resize(_size659); - uint32_t _i663; - for (_i663 = 0; _i663 < _size659; ++_i663) + uint32_t _size694; + ::apache::thrift::protocol::TType _etype697; + xfer += iprot->readListBegin(_etype697, _size694); + (*(this->success)).resize(_size694); + uint32_t _i698; + for (_i698 = 0; _i698 < _size694; ++_i698) { - xfer += (*(this->success))[_i663].read(iprot); + xfer += (*(this->success))[_i698].read(iprot); } xfer += iprot->readListEnd(); } @@ -12575,14 +13231,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size664; - ::apache::thrift::protocol::TType _etype667; - xfer += iprot->readListBegin(_etype667, _size664); - this->new_parts.resize(_size664); - uint32_t _i668; - for (_i668 = 0; _i668 < _size664; ++_i668) + uint32_t _size699; + ::apache::thrift::protocol::TType _etype702; + xfer += iprot->readListBegin(_etype702, _size699); + this->new_parts.resize(_size699); + uint32_t _i703; + for (_i703 = 0; _i703 < _size699; ++_i703) { - xfer += this->new_parts[_i668].read(iprot); + xfer += this->new_parts[_i703].read(iprot); } xfer += iprot->readListEnd(); } @@ -12618,10 +13274,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 _iter669; - for (_iter669 = this->new_parts.begin(); _iter669 != this->new_parts.end(); ++_iter669) + std::vector ::const_iterator _iter704; + for (_iter704 = this->new_parts.begin(); _iter704 != this->new_parts.end(); ++_iter704) { - xfer += (*_iter669).write(oprot); + xfer += (*_iter704).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12647,10 +13303,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 _iter670; - for (_iter670 = (*(this->new_parts)).begin(); _iter670 != (*(this->new_parts)).end(); ++_iter670) + std::vector ::const_iterator _iter705; + for (_iter705 = (*(this->new_parts)).begin(); _iter705 != (*(this->new_parts)).end(); ++_iter705) { - xfer += (*_iter670).write(oprot); + xfer += (*_iter705).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13047,14 +13703,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size671; - ::apache::thrift::protocol::TType _etype674; - xfer += iprot->readListBegin(_etype674, _size671); - this->part_vals.resize(_size671); - uint32_t _i675; - for (_i675 = 0; _i675 < _size671; ++_i675) + uint32_t _size706; + ::apache::thrift::protocol::TType _etype709; + xfer += iprot->readListBegin(_etype709, _size706); + this->part_vals.resize(_size706); + uint32_t _i710; + for (_i710 = 0; _i710 < _size706; ++_i710) { - xfer += iprot->readString(this->part_vals[_i675]); + xfer += iprot->readString(this->part_vals[_i710]); } xfer += iprot->readListEnd(); } @@ -13098,10 +13754,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 _iter676; - for (_iter676 = this->part_vals.begin(); _iter676 != this->part_vals.end(); ++_iter676) + std::vector ::const_iterator _iter711; + for (_iter711 = this->part_vals.begin(); _iter711 != this->part_vals.end(); ++_iter711) { - xfer += oprot->writeString((*_iter676)); + xfer += oprot->writeString((*_iter711)); } xfer += oprot->writeListEnd(); } @@ -13131,10 +13787,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 _iter677; - for (_iter677 = (*(this->part_vals)).begin(); _iter677 != (*(this->part_vals)).end(); ++_iter677) + std::vector ::const_iterator _iter712; + for (_iter712 = (*(this->part_vals)).begin(); _iter712 != (*(this->part_vals)).end(); ++_iter712) { - xfer += oprot->writeString((*_iter677)); + xfer += oprot->writeString((*_iter712)); } xfer += oprot->writeListEnd(); } @@ -13289,14 +13945,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 _size678; - ::apache::thrift::protocol::TType _etype681; - xfer += iprot->readListBegin(_etype681, _size678); - this->part_vals.resize(_size678); - uint32_t _i682; - for (_i682 = 0; _i682 < _size678; ++_i682) + uint32_t _size713; + ::apache::thrift::protocol::TType _etype716; + xfer += iprot->readListBegin(_etype716, _size713); + this->part_vals.resize(_size713); + uint32_t _i717; + for (_i717 = 0; _i717 < _size713; ++_i717) { - xfer += iprot->readString(this->part_vals[_i682]); + xfer += iprot->readString(this->part_vals[_i717]); } xfer += iprot->readListEnd(); } @@ -13332,10 +13988,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 _iter683; - for (_iter683 = this->part_vals.begin(); _iter683 != this->part_vals.end(); ++_iter683) + std::vector ::const_iterator _iter718; + for (_iter718 = this->part_vals.begin(); _iter718 != this->part_vals.end(); ++_iter718) { - xfer += oprot->writeString((*_iter683)); + xfer += oprot->writeString((*_iter718)); } xfer += oprot->writeListEnd(); } @@ -13357,10 +14013,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 _iter684; - for (_iter684 = (*(this->part_vals)).begin(); _iter684 != (*(this->part_vals)).end(); ++_iter684) + std::vector ::const_iterator _iter719; + for (_iter719 = (*(this->part_vals)).begin(); _iter719 != (*(this->part_vals)).end(); ++_iter719) { - xfer += oprot->writeString((*_iter684)); + xfer += oprot->writeString((*_iter719)); } xfer += oprot->writeListEnd(); } @@ -13779,14 +14435,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size685; - ::apache::thrift::protocol::TType _etype688; - xfer += iprot->readListBegin(_etype688, _size685); - this->success.resize(_size685); - uint32_t _i689; - for (_i689 = 0; _i689 < _size685; ++_i689) + uint32_t _size720; + ::apache::thrift::protocol::TType _etype723; + xfer += iprot->readListBegin(_etype723, _size720); + this->success.resize(_size720); + uint32_t _i724; + for (_i724 = 0; _i724 < _size720; ++_i724) { - xfer += iprot->readString(this->success[_i689]); + xfer += iprot->readString(this->success[_i724]); } xfer += iprot->readListEnd(); } @@ -13825,10 +14481,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 _iter690; - for (_iter690 = this->success.begin(); _iter690 != this->success.end(); ++_iter690) + std::vector ::const_iterator _iter725; + for (_iter725 = this->success.begin(); _iter725 != this->success.end(); ++_iter725) { - xfer += oprot->writeString((*_iter690)); + xfer += oprot->writeString((*_iter725)); } xfer += oprot->writeListEnd(); } @@ -13867,14 +14523,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size691; - ::apache::thrift::protocol::TType _etype694; - xfer += iprot->readListBegin(_etype694, _size691); - (*(this->success)).resize(_size691); - uint32_t _i695; - for (_i695 = 0; _i695 < _size691; ++_i695) + uint32_t _size726; + ::apache::thrift::protocol::TType _etype729; + xfer += iprot->readListBegin(_etype729, _size726); + (*(this->success)).resize(_size726); + uint32_t _i730; + for (_i730 = 0; _i730 < _size726; ++_i730) { - xfer += iprot->readString((*(this->success))[_i695]); + xfer += iprot->readString((*(this->success))[_i730]); } xfer += iprot->readListEnd(); } @@ -13993,17 +14649,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size696; - ::apache::thrift::protocol::TType _ktype697; - ::apache::thrift::protocol::TType _vtype698; - xfer += iprot->readMapBegin(_ktype697, _vtype698, _size696); - uint32_t _i700; - for (_i700 = 0; _i700 < _size696; ++_i700) + uint32_t _size731; + ::apache::thrift::protocol::TType _ktype732; + ::apache::thrift::protocol::TType _vtype733; + xfer += iprot->readMapBegin(_ktype732, _vtype733, _size731); + uint32_t _i735; + for (_i735 = 0; _i735 < _size731; ++_i735) { - std::string _key701; - xfer += iprot->readString(_key701); - std::string& _val702 = this->success[_key701]; - xfer += iprot->readString(_val702); + std::string _key736; + xfer += iprot->readString(_key736); + std::string& _val737 = this->success[_key736]; + xfer += iprot->readString(_val737); } xfer += iprot->readMapEnd(); } @@ -14042,11 +14698,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 _iter703; - for (_iter703 = this->success.begin(); _iter703 != this->success.end(); ++_iter703) + std::map ::const_iterator _iter738; + for (_iter738 = this->success.begin(); _iter738 != this->success.end(); ++_iter738) { - xfer += oprot->writeString(_iter703->first); - xfer += oprot->writeString(_iter703->second); + xfer += oprot->writeString(_iter738->first); + xfer += oprot->writeString(_iter738->second); } xfer += oprot->writeMapEnd(); } @@ -14085,17 +14741,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size704; - ::apache::thrift::protocol::TType _ktype705; - ::apache::thrift::protocol::TType _vtype706; - xfer += iprot->readMapBegin(_ktype705, _vtype706, _size704); - uint32_t _i708; - for (_i708 = 0; _i708 < _size704; ++_i708) + uint32_t _size739; + ::apache::thrift::protocol::TType _ktype740; + ::apache::thrift::protocol::TType _vtype741; + xfer += iprot->readMapBegin(_ktype740, _vtype741, _size739); + uint32_t _i743; + for (_i743 = 0; _i743 < _size739; ++_i743) { - std::string _key709; - xfer += iprot->readString(_key709); - std::string& _val710 = (*(this->success))[_key709]; - xfer += iprot->readString(_val710); + std::string _key744; + xfer += iprot->readString(_key744); + std::string& _val745 = (*(this->success))[_key744]; + xfer += iprot->readString(_val745); } xfer += iprot->readMapEnd(); } @@ -14164,17 +14820,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size711; - ::apache::thrift::protocol::TType _ktype712; - ::apache::thrift::protocol::TType _vtype713; - xfer += iprot->readMapBegin(_ktype712, _vtype713, _size711); - uint32_t _i715; - for (_i715 = 0; _i715 < _size711; ++_i715) + uint32_t _size746; + ::apache::thrift::protocol::TType _ktype747; + ::apache::thrift::protocol::TType _vtype748; + xfer += iprot->readMapBegin(_ktype747, _vtype748, _size746); + uint32_t _i750; + for (_i750 = 0; _i750 < _size746; ++_i750) { - std::string _key716; - xfer += iprot->readString(_key716); - std::string& _val717 = this->part_vals[_key716]; - xfer += iprot->readString(_val717); + std::string _key751; + xfer += iprot->readString(_key751); + std::string& _val752 = this->part_vals[_key751]; + xfer += iprot->readString(_val752); } xfer += iprot->readMapEnd(); } @@ -14185,9 +14841,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast718; - xfer += iprot->readI32(ecast718); - this->eventType = (PartitionEventType::type)ecast718; + int32_t ecast753; + xfer += iprot->readI32(ecast753); + this->eventType = (PartitionEventType::type)ecast753; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -14220,11 +14876,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 _iter719; - for (_iter719 = this->part_vals.begin(); _iter719 != this->part_vals.end(); ++_iter719) + std::map ::const_iterator _iter754; + for (_iter754 = this->part_vals.begin(); _iter754 != this->part_vals.end(); ++_iter754) { - xfer += oprot->writeString(_iter719->first); - xfer += oprot->writeString(_iter719->second); + xfer += oprot->writeString(_iter754->first); + xfer += oprot->writeString(_iter754->second); } xfer += oprot->writeMapEnd(); } @@ -14254,11 +14910,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 _iter720; - for (_iter720 = (*(this->part_vals)).begin(); _iter720 != (*(this->part_vals)).end(); ++_iter720) + std::map ::const_iterator _iter755; + for (_iter755 = (*(this->part_vals)).begin(); _iter755 != (*(this->part_vals)).end(); ++_iter755) { - xfer += oprot->writeString(_iter720->first); - xfer += oprot->writeString(_iter720->second); + xfer += oprot->writeString(_iter755->first); + xfer += oprot->writeString(_iter755->second); } xfer += oprot->writeMapEnd(); } @@ -14509,17 +15165,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size721; - ::apache::thrift::protocol::TType _ktype722; - ::apache::thrift::protocol::TType _vtype723; - xfer += iprot->readMapBegin(_ktype722, _vtype723, _size721); - uint32_t _i725; - for (_i725 = 0; _i725 < _size721; ++_i725) + uint32_t _size756; + ::apache::thrift::protocol::TType _ktype757; + ::apache::thrift::protocol::TType _vtype758; + xfer += iprot->readMapBegin(_ktype757, _vtype758, _size756); + uint32_t _i760; + for (_i760 = 0; _i760 < _size756; ++_i760) { - std::string _key726; - xfer += iprot->readString(_key726); - std::string& _val727 = this->part_vals[_key726]; - xfer += iprot->readString(_val727); + std::string _key761; + xfer += iprot->readString(_key761); + std::string& _val762 = this->part_vals[_key761]; + xfer += iprot->readString(_val762); } xfer += iprot->readMapEnd(); } @@ -14530,9 +15186,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast728; - xfer += iprot->readI32(ecast728); - this->eventType = (PartitionEventType::type)ecast728; + int32_t ecast763; + xfer += iprot->readI32(ecast763); + this->eventType = (PartitionEventType::type)ecast763; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -14565,11 +15221,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 _iter729; - for (_iter729 = this->part_vals.begin(); _iter729 != this->part_vals.end(); ++_iter729) + std::map ::const_iterator _iter764; + for (_iter764 = this->part_vals.begin(); _iter764 != this->part_vals.end(); ++_iter764) { - xfer += oprot->writeString(_iter729->first); - xfer += oprot->writeString(_iter729->second); + xfer += oprot->writeString(_iter764->first); + xfer += oprot->writeString(_iter764->second); } xfer += oprot->writeMapEnd(); } @@ -14599,11 +15255,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 _iter730; - for (_iter730 = (*(this->part_vals)).begin(); _iter730 != (*(this->part_vals)).end(); ++_iter730) + std::map ::const_iterator _iter765; + for (_iter765 = (*(this->part_vals)).begin(); _iter765 != (*(this->part_vals)).end(); ++_iter765) { - xfer += oprot->writeString(_iter730->first); - xfer += oprot->writeString(_iter730->second); + xfer += oprot->writeString(_iter765->first); + xfer += oprot->writeString(_iter765->second); } xfer += oprot->writeMapEnd(); } @@ -15908,14 +16564,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size731; - ::apache::thrift::protocol::TType _etype734; - xfer += iprot->readListBegin(_etype734, _size731); - this->success.resize(_size731); - uint32_t _i735; - for (_i735 = 0; _i735 < _size731; ++_i735) + uint32_t _size766; + ::apache::thrift::protocol::TType _etype769; + xfer += iprot->readListBegin(_etype769, _size766); + this->success.resize(_size766); + uint32_t _i770; + for (_i770 = 0; _i770 < _size766; ++_i770) { - xfer += this->success[_i735].read(iprot); + xfer += this->success[_i770].read(iprot); } xfer += iprot->readListEnd(); } @@ -15962,10 +16618,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 _iter736; - for (_iter736 = this->success.begin(); _iter736 != this->success.end(); ++_iter736) + std::vector ::const_iterator _iter771; + for (_iter771 = this->success.begin(); _iter771 != this->success.end(); ++_iter771) { - xfer += (*_iter736).write(oprot); + xfer += (*_iter771).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16008,14 +16664,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size737; - ::apache::thrift::protocol::TType _etype740; - xfer += iprot->readListBegin(_etype740, _size737); - (*(this->success)).resize(_size737); - uint32_t _i741; - for (_i741 = 0; _i741 < _size737; ++_i741) + uint32_t _size772; + ::apache::thrift::protocol::TType _etype775; + xfer += iprot->readListBegin(_etype775, _size772); + (*(this->success)).resize(_size772); + uint32_t _i776; + for (_i776 = 0; _i776 < _size772; ++_i776) { - xfer += (*(this->success))[_i741].read(iprot); + xfer += (*(this->success))[_i776].read(iprot); } xfer += iprot->readListEnd(); } @@ -16174,14 +16830,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size742; - ::apache::thrift::protocol::TType _etype745; - xfer += iprot->readListBegin(_etype745, _size742); - this->success.resize(_size742); - uint32_t _i746; - for (_i746 = 0; _i746 < _size742; ++_i746) + uint32_t _size777; + ::apache::thrift::protocol::TType _etype780; + xfer += iprot->readListBegin(_etype780, _size777); + this->success.resize(_size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - xfer += iprot->readString(this->success[_i746]); + xfer += iprot->readString(this->success[_i781]); } xfer += iprot->readListEnd(); } @@ -16220,10 +16876,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 _iter747; - for (_iter747 = this->success.begin(); _iter747 != this->success.end(); ++_iter747) + std::vector ::const_iterator _iter782; + for (_iter782 = this->success.begin(); _iter782 != this->success.end(); ++_iter782) { - xfer += oprot->writeString((*_iter747)); + xfer += oprot->writeString((*_iter782)); } xfer += oprot->writeListEnd(); } @@ -16262,14 +16918,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size748; - ::apache::thrift::protocol::TType _etype751; - xfer += iprot->readListBegin(_etype751, _size748); - (*(this->success)).resize(_size748); - uint32_t _i752; - for (_i752 = 0; _i752 < _size748; ++_i752) + uint32_t _size783; + ::apache::thrift::protocol::TType _etype786; + xfer += iprot->readListBegin(_etype786, _size783); + (*(this->success)).resize(_size783); + uint32_t _i787; + for (_i787 = 0; _i787 < _size783; ++_i787) { - xfer += iprot->readString((*(this->success))[_i752]); + xfer += iprot->readString((*(this->success))[_i787]); } xfer += iprot->readListEnd(); } @@ -19054,14 +19710,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size753; - ::apache::thrift::protocol::TType _etype756; - xfer += iprot->readListBegin(_etype756, _size753); - this->success.resize(_size753); - uint32_t _i757; - for (_i757 = 0; _i757 < _size753; ++_i757) + uint32_t _size788; + ::apache::thrift::protocol::TType _etype791; + xfer += iprot->readListBegin(_etype791, _size788); + this->success.resize(_size788); + uint32_t _i792; + for (_i792 = 0; _i792 < _size788; ++_i792) { - xfer += iprot->readString(this->success[_i757]); + xfer += iprot->readString(this->success[_i792]); } xfer += iprot->readListEnd(); } @@ -19100,10 +19756,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 _iter758; - for (_iter758 = this->success.begin(); _iter758 != this->success.end(); ++_iter758) + std::vector ::const_iterator _iter793; + for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) { - xfer += oprot->writeString((*_iter758)); + xfer += oprot->writeString((*_iter793)); } xfer += oprot->writeListEnd(); } @@ -19142,14 +19798,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size759; - ::apache::thrift::protocol::TType _etype762; - xfer += iprot->readListBegin(_etype762, _size759); - (*(this->success)).resize(_size759); - uint32_t _i763; - for (_i763 = 0; _i763 < _size759; ++_i763) + uint32_t _size794; + ::apache::thrift::protocol::TType _etype797; + xfer += iprot->readListBegin(_etype797, _size794); + (*(this->success)).resize(_size794); + uint32_t _i798; + for (_i798 = 0; _i798 < _size794; ++_i798) { - xfer += iprot->readString((*(this->success))[_i763]); + xfer += iprot->readString((*(this->success))[_i798]); } xfer += iprot->readListEnd(); } @@ -19829,14 +20485,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size764; - ::apache::thrift::protocol::TType _etype767; - xfer += iprot->readListBegin(_etype767, _size764); - this->success.resize(_size764); - uint32_t _i768; - for (_i768 = 0; _i768 < _size764; ++_i768) + uint32_t _size799; + ::apache::thrift::protocol::TType _etype802; + xfer += iprot->readListBegin(_etype802, _size799); + this->success.resize(_size799); + uint32_t _i803; + for (_i803 = 0; _i803 < _size799; ++_i803) { - xfer += iprot->readString(this->success[_i768]); + xfer += iprot->readString(this->success[_i803]); } xfer += iprot->readListEnd(); } @@ -19875,10 +20531,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 _iter769; - for (_iter769 = this->success.begin(); _iter769 != this->success.end(); ++_iter769) + std::vector ::const_iterator _iter804; + for (_iter804 = this->success.begin(); _iter804 != this->success.end(); ++_iter804) { - xfer += oprot->writeString((*_iter769)); + xfer += oprot->writeString((*_iter804)); } xfer += oprot->writeListEnd(); } @@ -19917,14 +20573,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size770; - ::apache::thrift::protocol::TType _etype773; - xfer += iprot->readListBegin(_etype773, _size770); - (*(this->success)).resize(_size770); - uint32_t _i774; - for (_i774 = 0; _i774 < _size770; ++_i774) + uint32_t _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readListBegin(_etype808, _size805); + (*(this->success)).resize(_size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) { - xfer += iprot->readString((*(this->success))[_i774]); + xfer += iprot->readString((*(this->success))[_i809]); } xfer += iprot->readListEnd(); } @@ -19991,9 +20647,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast775; - xfer += iprot->readI32(ecast775); - this->principal_type = (PrincipalType::type)ecast775; + int32_t ecast810; + xfer += iprot->readI32(ecast810); + this->principal_type = (PrincipalType::type)ecast810; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -20009,9 +20665,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast776; - xfer += iprot->readI32(ecast776); - this->grantorType = (PrincipalType::type)ecast776; + int32_t ecast811; + xfer += iprot->readI32(ecast811); + this->grantorType = (PrincipalType::type)ecast811; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -20257,9 +20913,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast777; - xfer += iprot->readI32(ecast777); - this->principal_type = (PrincipalType::type)ecast777; + int32_t ecast812; + xfer += iprot->readI32(ecast812); + this->principal_type = (PrincipalType::type)ecast812; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -20465,9 +21121,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast778; - xfer += iprot->readI32(ecast778); - this->principal_type = (PrincipalType::type)ecast778; + int32_t ecast813; + xfer += iprot->readI32(ecast813); + this->principal_type = (PrincipalType::type)ecast813; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -20543,14 +21199,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size779; - ::apache::thrift::protocol::TType _etype782; - xfer += iprot->readListBegin(_etype782, _size779); - this->success.resize(_size779); - uint32_t _i783; - for (_i783 = 0; _i783 < _size779; ++_i783) + uint32_t _size814; + ::apache::thrift::protocol::TType _etype817; + xfer += iprot->readListBegin(_etype817, _size814); + this->success.resize(_size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - xfer += this->success[_i783].read(iprot); + xfer += this->success[_i818].read(iprot); } xfer += iprot->readListEnd(); } @@ -20589,10 +21245,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 _iter784; - for (_iter784 = this->success.begin(); _iter784 != this->success.end(); ++_iter784) + std::vector ::const_iterator _iter819; + for (_iter819 = this->success.begin(); _iter819 != this->success.end(); ++_iter819) { - xfer += (*_iter784).write(oprot); + xfer += (*_iter819).write(oprot); } xfer += oprot->writeListEnd(); } @@ -20631,14 +21287,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size785; - ::apache::thrift::protocol::TType _etype788; - xfer += iprot->readListBegin(_etype788, _size785); - (*(this->success)).resize(_size785); - uint32_t _i789; - for (_i789 = 0; _i789 < _size785; ++_i789) + uint32_t _size820; + ::apache::thrift::protocol::TType _etype823; + xfer += iprot->readListBegin(_etype823, _size820); + (*(this->success)).resize(_size820); + uint32_t _i824; + for (_i824 = 0; _i824 < _size820; ++_i824) { - xfer += (*(this->success))[_i789].read(iprot); + xfer += (*(this->success))[_i824].read(iprot); } xfer += iprot->readListEnd(); } @@ -21071,14 +21727,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 _size790; - ::apache::thrift::protocol::TType _etype793; - xfer += iprot->readListBegin(_etype793, _size790); - this->group_names.resize(_size790); - uint32_t _i794; - for (_i794 = 0; _i794 < _size790; ++_i794) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + this->group_names.resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += iprot->readString(this->group_names[_i794]); + xfer += iprot->readString(this->group_names[_i829]); } xfer += iprot->readListEnd(); } @@ -21114,10 +21770,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 _iter795; - for (_iter795 = this->group_names.begin(); _iter795 != this->group_names.end(); ++_iter795) + std::vector ::const_iterator _iter830; + for (_iter830 = this->group_names.begin(); _iter830 != this->group_names.end(); ++_iter830) { - xfer += oprot->writeString((*_iter795)); + xfer += oprot->writeString((*_iter830)); } xfer += oprot->writeListEnd(); } @@ -21143,10 +21799,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 _iter796; - for (_iter796 = (*(this->group_names)).begin(); _iter796 != (*(this->group_names)).end(); ++_iter796) + std::vector ::const_iterator _iter831; + for (_iter831 = (*(this->group_names)).begin(); _iter831 != (*(this->group_names)).end(); ++_iter831) { - xfer += oprot->writeString((*_iter796)); + xfer += oprot->writeString((*_iter831)); } xfer += oprot->writeListEnd(); } @@ -21303,9 +21959,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast797; - xfer += iprot->readI32(ecast797); - this->principal_type = (PrincipalType::type)ecast797; + int32_t ecast832; + xfer += iprot->readI32(ecast832); + this->principal_type = (PrincipalType::type)ecast832; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -21397,14 +22053,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size798; - ::apache::thrift::protocol::TType _etype801; - xfer += iprot->readListBegin(_etype801, _size798); - this->success.resize(_size798); - uint32_t _i802; - for (_i802 = 0; _i802 < _size798; ++_i802) + uint32_t _size833; + ::apache::thrift::protocol::TType _etype836; + xfer += iprot->readListBegin(_etype836, _size833); + this->success.resize(_size833); + uint32_t _i837; + for (_i837 = 0; _i837 < _size833; ++_i837) { - xfer += this->success[_i802].read(iprot); + xfer += this->success[_i837].read(iprot); } xfer += iprot->readListEnd(); } @@ -21443,10 +22099,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 _iter803; - for (_iter803 = this->success.begin(); _iter803 != this->success.end(); ++_iter803) + std::vector ::const_iterator _iter838; + for (_iter838 = this->success.begin(); _iter838 != this->success.end(); ++_iter838) { - xfer += (*_iter803).write(oprot); + xfer += (*_iter838).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21485,14 +22141,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size804; - ::apache::thrift::protocol::TType _etype807; - xfer += iprot->readListBegin(_etype807, _size804); - (*(this->success)).resize(_size804); - uint32_t _i808; - for (_i808 = 0; _i808 < _size804; ++_i808) + uint32_t _size839; + ::apache::thrift::protocol::TType _etype842; + xfer += iprot->readListBegin(_etype842, _size839); + (*(this->success)).resize(_size839); + uint32_t _i843; + for (_i843 = 0; _i843 < _size839; ++_i843) { - xfer += (*(this->success))[_i808].read(iprot); + xfer += (*(this->success))[_i843].read(iprot); } xfer += iprot->readListEnd(); } @@ -21917,14 +22573,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 _size809; - ::apache::thrift::protocol::TType _etype812; - xfer += iprot->readListBegin(_etype812, _size809); - this->group_names.resize(_size809); - uint32_t _i813; - for (_i813 = 0; _i813 < _size809; ++_i813) + uint32_t _size844; + ::apache::thrift::protocol::TType _etype847; + xfer += iprot->readListBegin(_etype847, _size844); + this->group_names.resize(_size844); + uint32_t _i848; + for (_i848 = 0; _i848 < _size844; ++_i848) { - xfer += iprot->readString(this->group_names[_i813]); + xfer += iprot->readString(this->group_names[_i848]); } xfer += iprot->readListEnd(); } @@ -21956,10 +22612,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 _iter814; - for (_iter814 = this->group_names.begin(); _iter814 != this->group_names.end(); ++_iter814) + std::vector ::const_iterator _iter849; + for (_iter849 = this->group_names.begin(); _iter849 != this->group_names.end(); ++_iter849) { - xfer += oprot->writeString((*_iter814)); + xfer += oprot->writeString((*_iter849)); } xfer += oprot->writeListEnd(); } @@ -21981,10 +22637,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 _iter815; - for (_iter815 = (*(this->group_names)).begin(); _iter815 != (*(this->group_names)).end(); ++_iter815) + std::vector ::const_iterator _iter850; + for (_iter850 = (*(this->group_names)).begin(); _iter850 != (*(this->group_names)).end(); ++_iter850) { - xfer += oprot->writeString((*_iter815)); + xfer += oprot->writeString((*_iter850)); } xfer += oprot->writeListEnd(); } @@ -22019,14 +22675,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size816; - ::apache::thrift::protocol::TType _etype819; - xfer += iprot->readListBegin(_etype819, _size816); - this->success.resize(_size816); - uint32_t _i820; - for (_i820 = 0; _i820 < _size816; ++_i820) + uint32_t _size851; + ::apache::thrift::protocol::TType _etype854; + xfer += iprot->readListBegin(_etype854, _size851); + this->success.resize(_size851); + uint32_t _i855; + for (_i855 = 0; _i855 < _size851; ++_i855) { - xfer += iprot->readString(this->success[_i820]); + xfer += iprot->readString(this->success[_i855]); } xfer += iprot->readListEnd(); } @@ -22065,10 +22721,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 _iter821; - for (_iter821 = this->success.begin(); _iter821 != this->success.end(); ++_iter821) + std::vector ::const_iterator _iter856; + for (_iter856 = this->success.begin(); _iter856 != this->success.end(); ++_iter856) { - xfer += oprot->writeString((*_iter821)); + xfer += oprot->writeString((*_iter856)); } xfer += oprot->writeListEnd(); } @@ -22107,14 +22763,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size822; - ::apache::thrift::protocol::TType _etype825; - xfer += iprot->readListBegin(_etype825, _size822); - (*(this->success)).resize(_size822); - uint32_t _i826; - for (_i826 = 0; _i826 < _size822; ++_i826) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + (*(this->success)).resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += iprot->readString((*(this->success))[_i826]); + xfer += iprot->readString((*(this->success))[_i861]); } xfer += iprot->readListEnd(); } @@ -26910,6 +27566,141 @@ void ThriftHiveMetastoreClient::recv_append_partition_by_name_with_environment_c throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "append_partition_by_name_with_environment_context failed: unknown result"); } +bool ThriftHiveMetastoreClient::add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData) +{ + send_add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData); + return recv_add_drop_partitions(); +} + +void ThriftHiveMetastoreClient::send_add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("add_drop_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_add_drop_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.add_parts = &add_parts; + args.drop_part_vals = &drop_part_vals; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_add_drop_partitions() +{ + + 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("add_drop_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_add_drop_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _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, "add_drop_partitions failed: unknown result"); +} + +bool ThriftHiveMetastoreClient::drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData) +{ + send_drop_partitions(db_name, tbl_name, part_vals, deleteData); + return recv_drop_partitions(); +} + +void ThriftHiveMetastoreClient::send_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("drop_partitions", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_drop_partitions_pargs args; + args.db_name = &db_name; + args.tbl_name = &tbl_name; + args.part_vals = &part_vals; + args.deleteData = &deleteData; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_drop_partitions() +{ + + 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("drop_partitions") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_drop_partitions_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "drop_partitions failed: unknown result"); +} + bool ThriftHiveMetastoreClient::drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) { send_drop_partition(db_name, tbl_name, part_vals, deleteData); @@ -33676,6 +34467,126 @@ void ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environ } } +void ThriftHiveMetastoreProcessor::process_add_drop_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.add_drop_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.add_drop_partitions"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.add_drop_partitions"); + } + + ThriftHiveMetastore_add_drop_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.add_drop_partitions", bytes); + } + + ThriftHiveMetastore_add_drop_partitions_result result; + try { + result.success = iface_->add_drop_partitions(args.db_name, args.tbl_name, args.add_parts, args.drop_part_vals, args.deleteData); + result.__isset.success = true; + } catch (InvalidObjectException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (AlreadyExistsException &o2) { + result.o2 = o2; + result.__isset.o2 = true; + } catch (NoSuchObjectException &o3) { + result.o3 = o3; + result.__isset.o3 = true; + } catch (MetaException &o4) { + result.o4 = o4; + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.add_drop_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("add_drop_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.add_drop_partitions"); + } + + oprot->writeMessageBegin("add_drop_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.add_drop_partitions", bytes); + } +} + +void ThriftHiveMetastoreProcessor::process_drop_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.drop_partitions", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.drop_partitions"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.drop_partitions"); + } + + ThriftHiveMetastore_drop_partitions_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.drop_partitions", bytes); + } + + ThriftHiveMetastore_drop_partitions_result result; + try { + result.success = iface_->drop_partitions(args.db_name, args.tbl_name, args.part_vals, args.deleteData); + result.__isset.success = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.drop_partitions"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("drop_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.drop_partitions"); + } + + oprot->writeMessageBegin("drop_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.drop_partitions", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 2a1b4d7..fb90c4c 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -47,6 +47,8 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const EnvironmentContext& environment_context) = 0; virtual void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0; virtual void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) = 0; + virtual bool add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData) = 0; + virtual bool drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData) = 0; virtual bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) = 0; virtual bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData, const EnvironmentContext& environment_context) = 0; virtual bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) = 0; @@ -248,6 +250,14 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void append_partition_by_name_with_environment_context(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const EnvironmentContext& /* environment_context */) { return; } + bool add_drop_partitions(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* add_parts */, const std::vector > & /* drop_part_vals */, const bool /* deleteData */) { + bool _return = false; + return _return; + } + bool drop_partitions(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector > & /* part_vals */, const bool /* deleteData */) { + bool _return = false; + return _return; + } bool drop_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector & /* part_vals */, const bool /* deleteData */) { bool _return = false; return _return; @@ -4788,6 +4798,325 @@ class ThriftHiveMetastore_append_partition_by_name_with_environment_context_pres }; +typedef struct _ThriftHiveMetastore_add_drop_partitions_args__isset { + _ThriftHiveMetastore_add_drop_partitions_args__isset() : db_name(false), tbl_name(false), add_parts(false), drop_part_vals(false), deleteData(false) {} + bool db_name; + bool tbl_name; + bool add_parts; + bool drop_part_vals; + bool deleteData; +} _ThriftHiveMetastore_add_drop_partitions_args__isset; + +class ThriftHiveMetastore_add_drop_partitions_args { + public: + + ThriftHiveMetastore_add_drop_partitions_args() : db_name(), tbl_name(), deleteData(0) { + } + + virtual ~ThriftHiveMetastore_add_drop_partitions_args() throw() {} + + std::string db_name; + std::string tbl_name; + std::vector add_parts; + std::vector > drop_part_vals; + bool deleteData; + + _ThriftHiveMetastore_add_drop_partitions_args__isset __isset; + + void __set_db_name(const std::string& val) { + db_name = val; + } + + void __set_tbl_name(const std::string& val) { + tbl_name = val; + } + + void __set_add_parts(const std::vector & val) { + add_parts = val; + } + + void __set_drop_part_vals(const std::vector > & val) { + drop_part_vals = val; + } + + void __set_deleteData(const bool val) { + deleteData = val; + } + + bool operator == (const ThriftHiveMetastore_add_drop_partitions_args & rhs) const + { + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (!(add_parts == rhs.add_parts)) + return false; + if (!(drop_part_vals == rhs.drop_part_vals)) + return false; + if (!(deleteData == rhs.deleteData)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_add_drop_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_drop_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_drop_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_drop_partitions_pargs() throw() {} + + const std::string* db_name; + const std::string* tbl_name; + const std::vector * add_parts; + const std::vector > * drop_part_vals; + const bool* deleteData; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_drop_partitions_result__isset { + _ThriftHiveMetastore_add_drop_partitions_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success; + bool o1; + bool o2; + bool o3; + bool o4; +} _ThriftHiveMetastore_add_drop_partitions_result__isset; + +class ThriftHiveMetastore_add_drop_partitions_result { + public: + + ThriftHiveMetastore_add_drop_partitions_result() : success(0) { + } + + virtual ~ThriftHiveMetastore_add_drop_partitions_result() throw() {} + + bool success; + InvalidObjectException o1; + AlreadyExistsException o2; + NoSuchObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_add_drop_partitions_result__isset __isset; + + void __set_success(const bool val) { + success = val; + } + + void __set_o1(const InvalidObjectException& val) { + o1 = val; + } + + void __set_o2(const AlreadyExistsException& val) { + o2 = val; + } + + void __set_o3(const NoSuchObjectException& val) { + o3 = val; + } + + void __set_o4(const MetaException& val) { + o4 = val; + } + + bool operator == (const ThriftHiveMetastore_add_drop_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_add_drop_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_drop_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_drop_partitions_presult__isset { + _ThriftHiveMetastore_add_drop_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success; + bool o1; + bool o2; + bool o3; + bool o4; +} _ThriftHiveMetastore_add_drop_partitions_presult__isset; + +class ThriftHiveMetastore_add_drop_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_add_drop_partitions_presult() throw() {} + + bool* success; + InvalidObjectException o1; + AlreadyExistsException o2; + NoSuchObjectException o3; + MetaException o4; + + _ThriftHiveMetastore_add_drop_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_args__isset { + _ThriftHiveMetastore_drop_partitions_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false) {} + bool db_name; + bool tbl_name; + bool part_vals; + bool deleteData; +} _ThriftHiveMetastore_drop_partitions_args__isset; + +class ThriftHiveMetastore_drop_partitions_args { + public: + + ThriftHiveMetastore_drop_partitions_args() : db_name(), tbl_name(), deleteData(0) { + } + + virtual ~ThriftHiveMetastore_drop_partitions_args() throw() {} + + std::string db_name; + std::string tbl_name; + std::vector > part_vals; + bool deleteData; + + _ThriftHiveMetastore_drop_partitions_args__isset __isset; + + void __set_db_name(const std::string& val) { + db_name = val; + } + + void __set_tbl_name(const std::string& val) { + tbl_name = val; + } + + void __set_part_vals(const std::vector > & val) { + part_vals = val; + } + + void __set_deleteData(const bool val) { + deleteData = val; + } + + bool operator == (const ThriftHiveMetastore_drop_partitions_args & rhs) const + { + if (!(db_name == rhs.db_name)) + return false; + if (!(tbl_name == rhs.tbl_name)) + return false; + if (!(part_vals == rhs.part_vals)) + return false; + if (!(deleteData == rhs.deleteData)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_partitions_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partitions_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_drop_partitions_pargs { + public: + + + virtual ~ThriftHiveMetastore_drop_partitions_pargs() throw() {} + + const std::string* db_name; + const std::string* tbl_name; + const std::vector > * part_vals; + const bool* deleteData; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_result__isset { + _ThriftHiveMetastore_drop_partitions_result__isset() : success(false) {} + bool success; +} _ThriftHiveMetastore_drop_partitions_result__isset; + +class ThriftHiveMetastore_drop_partitions_result { + public: + + ThriftHiveMetastore_drop_partitions_result() : success(0) { + } + + virtual ~ThriftHiveMetastore_drop_partitions_result() throw() {} + + bool success; + + _ThriftHiveMetastore_drop_partitions_result__isset __isset; + + void __set_success(const bool val) { + success = val; + } + + bool operator == (const ThriftHiveMetastore_drop_partitions_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_drop_partitions_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_drop_partitions_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_drop_partitions_presult__isset { + _ThriftHiveMetastore_drop_partitions_presult__isset() : success(false) {} + bool success; +} _ThriftHiveMetastore_drop_partitions_presult__isset; + +class ThriftHiveMetastore_drop_partitions_presult { + public: + + + virtual ~ThriftHiveMetastore_drop_partitions_presult() throw() {} + + bool* success; + + _ThriftHiveMetastore_drop_partitions_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_drop_partition_args__isset { _ThriftHiveMetastore_drop_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false) {} bool db_name; @@ -15299,6 +15628,12 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context); void recv_append_partition_by_name_with_environment_context(Partition& _return); + bool add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData); + void send_add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData); + bool recv_add_drop_partitions(); + bool drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData); + void send_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData); + bool recv_drop_partitions(); bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData); bool recv_drop_partition(); @@ -15568,6 +15903,8 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_append_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_append_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_drop_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_drop_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -15679,6 +16016,8 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["append_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_with_environment_context; processMap_["append_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name; processMap_["append_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environment_context; + processMap_["add_drop_partitions"] = &ThriftHiveMetastoreProcessor::process_add_drop_partitions; + processMap_["drop_partitions"] = &ThriftHiveMetastoreProcessor::process_drop_partitions; processMap_["drop_partition"] = &ThriftHiveMetastoreProcessor::process_drop_partition; processMap_["drop_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_partition_with_environment_context; processMap_["drop_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name; @@ -16086,6 +16425,24 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + bool add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData); + } + return ifaces_[i]->add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData); + } + + bool drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->drop_partitions(db_name, tbl_name, part_vals, deleteData); + } + return ifaces_[i]->drop_partitions(db_name, tbl_name, part_vals, deleteData); + } + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) { size_t sz = ifaces_.size(); size_t i = 0; 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 b18009c..dce126e 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -177,6 +177,16 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("append_partition_by_name_with_environment_context\n"); } + bool add_drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector & add_parts, const std::vector > & drop_part_vals, const bool deleteData) { + // Your implementation goes here + printf("add_drop_partitions\n"); + } + + bool drop_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector > & part_vals, const bool deleteData) { + // Your implementation goes here + printf("drop_partitions\n"); + } + bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector & part_vals, const bool deleteData) { // Your implementation goes here printf("drop_partition\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 4f051af..99acfd2 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 @@ -100,6 +100,10 @@ public Partition append_partition_by_name_with_environment_context(String db_name, String tbl_name, String part_name, EnvironmentContext environment_context) throws InvalidObjectException, AlreadyExistsException, MetaException, org.apache.thrift.TException; + public boolean add_drop_partitions(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData) throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, MetaException, org.apache.thrift.TException; + + public boolean drop_partitions(String db_name, String tbl_name, List> part_vals, boolean deleteData) throws org.apache.thrift.TException; + public boolean drop_partition(String db_name, String tbl_name, List part_vals, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; public boolean drop_partition_with_environment_context(String db_name, String tbl_name, List part_vals, boolean deleteData, EnvironmentContext environment_context) throws NoSuchObjectException, MetaException, org.apache.thrift.TException; @@ -318,6 +322,10 @@ public void append_partition_by_name_with_environment_context(String db_name, String tbl_name, String part_name, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void add_drop_partitions(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + + public void drop_partitions(String db_name, String tbl_name, List> part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void drop_partition(String db_name, String tbl_name, List part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void drop_partition_with_environment_context(String db_name, String tbl_name, List part_vals, boolean deleteData, EnvironmentContext environment_context, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -1437,6 +1445,71 @@ public Partition recv_append_partition_by_name_with_environment_context() throws throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "append_partition_by_name_with_environment_context failed: unknown result"); } + public boolean add_drop_partitions(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData) throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, MetaException, org.apache.thrift.TException + { + send_add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData); + return recv_add_drop_partitions(); + } + + public void send_add_drop_partitions(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData) throws org.apache.thrift.TException + { + add_drop_partitions_args args = new add_drop_partitions_args(); + args.setDb_name(db_name); + args.setTbl_name(tbl_name); + args.setAdd_parts(add_parts); + args.setDrop_part_vals(drop_part_vals); + args.setDeleteData(deleteData); + sendBase("add_drop_partitions", args); + } + + public boolean recv_add_drop_partitions() throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, MetaException, org.apache.thrift.TException + { + add_drop_partitions_result result = new add_drop_partitions_result(); + receiveBase(result, "add_drop_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, "add_drop_partitions failed: unknown result"); + } + + public boolean drop_partitions(String db_name, String tbl_name, List> part_vals, boolean deleteData) throws org.apache.thrift.TException + { + send_drop_partitions(db_name, tbl_name, part_vals, deleteData); + return recv_drop_partitions(); + } + + public void send_drop_partitions(String db_name, String tbl_name, List> part_vals, boolean deleteData) throws org.apache.thrift.TException + { + drop_partitions_args args = new drop_partitions_args(); + args.setDb_name(db_name); + args.setTbl_name(tbl_name); + args.setPart_vals(part_vals); + args.setDeleteData(deleteData); + sendBase("drop_partitions", args); + } + + public boolean recv_drop_partitions() throws org.apache.thrift.TException + { + drop_partitions_result result = new drop_partitions_result(); + receiveBase(result, "drop_partitions"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "drop_partitions failed: unknown result"); + } + public boolean drop_partition(String db_name, String tbl_name, List part_vals, boolean deleteData) throws NoSuchObjectException, MetaException, org.apache.thrift.TException { send_drop_partition(db_name, tbl_name, part_vals, deleteData); @@ -4773,6 +4846,91 @@ public Partition getResult() throws InvalidObjectException, AlreadyExistsExcepti } } + public void add_drop_partitions(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + add_drop_partitions_call method_call = new add_drop_partitions_call(db_name, tbl_name, add_parts, drop_part_vals, deleteData, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class add_drop_partitions_call extends org.apache.thrift.async.TAsyncMethodCall { + private String db_name; + private String tbl_name; + private List add_parts; + private List> drop_part_vals; + private boolean deleteData; + public add_drop_partitions_call(String db_name, String tbl_name, List add_parts, List> drop_part_vals, boolean deleteData, 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.db_name = db_name; + this.tbl_name = tbl_name; + this.add_parts = add_parts; + this.drop_part_vals = drop_part_vals; + this.deleteData = deleteData; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("add_drop_partitions", org.apache.thrift.protocol.TMessageType.CALL, 0)); + add_drop_partitions_args args = new add_drop_partitions_args(); + args.setDb_name(db_name); + args.setTbl_name(tbl_name); + args.setAdd_parts(add_parts); + args.setDrop_part_vals(drop_part_vals); + args.setDeleteData(deleteData); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, MetaException, 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_add_drop_partitions(); + } + } + + public void drop_partitions(String db_name, String tbl_name, List> part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + drop_partitions_call method_call = new drop_partitions_call(db_name, tbl_name, part_vals, deleteData, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class drop_partitions_call extends org.apache.thrift.async.TAsyncMethodCall { + private String db_name; + private String tbl_name; + private List> part_vals; + private boolean deleteData; + public drop_partitions_call(String db_name, String tbl_name, List> part_vals, boolean deleteData, 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.db_name = db_name; + this.tbl_name = tbl_name; + this.part_vals = part_vals; + this.deleteData = deleteData; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("drop_partitions", org.apache.thrift.protocol.TMessageType.CALL, 0)); + drop_partitions_args args = new drop_partitions_args(); + args.setDb_name(db_name); + args.setTbl_name(tbl_name); + args.setPart_vals(part_vals); + args.setDeleteData(deleteData); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws 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_drop_partitions(); + } + } + public void drop_partition(String db_name, String tbl_name, List part_vals, boolean deleteData, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); drop_partition_call method_call = new drop_partition_call(db_name, tbl_name, part_vals, deleteData, resultHandler, this, ___protocolFactory, ___transport); @@ -7570,6 +7728,8 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public add_drop_partitions() { + super("add_drop_partitions"); + } + + public add_drop_partitions_args getEmptyArgsInstance() { + return new add_drop_partitions_args(); + } + + protected boolean isOneway() { + return false; + } + + public add_drop_partitions_result getResult(I iface, add_drop_partitions_args args) throws org.apache.thrift.TException { + add_drop_partitions_result result = new add_drop_partitions_result(); + try { + result.success = iface.add_drop_partitions(args.db_name, args.tbl_name, args.add_parts, args.drop_part_vals, args.deleteData); + result.setSuccessIsSet(true); + } catch (InvalidObjectException o1) { + result.o1 = o1; + } catch (AlreadyExistsException o2) { + result.o2 = o2; + } catch (NoSuchObjectException o3) { + result.o3 = o3; + } catch (MetaException o4) { + result.o4 = o4; + } + return result; + } + } + + public static class drop_partitions extends org.apache.thrift.ProcessFunction { + public drop_partitions() { + super("drop_partitions"); + } + + public drop_partitions_args getEmptyArgsInstance() { + return new drop_partitions_args(); + } + + protected boolean isOneway() { + return false; + } + + public drop_partitions_result getResult(I iface, drop_partitions_args args) throws org.apache.thrift.TException { + drop_partitions_result result = new drop_partitions_result(); + result.success = iface.drop_partitions(args.db_name, args.tbl_name, args.part_vals, args.deleteData); + result.setSuccessIsSet(true); + return result; + } + } + public static class drop_partition extends org.apache.thrift.ProcessFunction { public drop_partition() { super("drop_partition"); @@ -43793,31 +44005,34 @@ public void read(org.apache.thrift.protocol.TProtocol prot, append_partition_by_ } - public static class drop_partition_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_args"); + public static class add_drop_partitions_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("add_drop_partitions_args"); private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("part_vals", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); + private static final org.apache.thrift.protocol.TField ADD_PARTS_FIELD_DESC = new org.apache.thrift.protocol.TField("add_parts", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final org.apache.thrift.protocol.TField DROP_PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("drop_part_vals", org.apache.thrift.protocol.TType.LIST, (short)4); + private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new add_drop_partitions_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new add_drop_partitions_argsTupleSchemeFactory()); } private String db_name; // required private String tbl_name; // required - private List part_vals; // required + private List add_parts; // required + private List> drop_part_vals; // required private boolean deleteData; // 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 { DB_NAME((short)1, "db_name"), TBL_NAME((short)2, "tbl_name"), - PART_VALS((short)3, "part_vals"), - DELETE_DATA((short)4, "deleteData"); + ADD_PARTS((short)3, "add_parts"), + DROP_PART_VALS((short)4, "drop_part_vals"), + DELETE_DATA((short)5, "deleteData"); private static final Map byName = new HashMap(); @@ -43836,9 +44051,11 @@ public static _Fields findByThriftId(int fieldId) { return DB_NAME; case 2: // TBL_NAME return TBL_NAME; - case 3: // PART_VALS - return PART_VALS; - case 4: // DELETE_DATA + case 3: // ADD_PARTS + return ADD_PARTS; + case 4: // DROP_PART_VALS + return DROP_PART_VALS; + case 5: // DELETE_DATA return DELETE_DATA; default: return null; @@ -43889,28 +44106,34 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tbl_name", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, + tmpMap.put(_Fields.ADD_PARTS, new org.apache.thrift.meta_data.FieldMetaData("add_parts", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class)))); + tmpMap.put(_Fields.DROP_PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("drop_part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))))); tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(add_drop_partitions_args.class, metaDataMap); } - public drop_partition_args() { + public add_drop_partitions_args() { } - public drop_partition_args( + public add_drop_partitions_args( String db_name, String tbl_name, - List part_vals, + List add_parts, + List> drop_part_vals, boolean deleteData) { this(); this.db_name = db_name; this.tbl_name = tbl_name; - this.part_vals = part_vals; + this.add_parts = add_parts; + this.drop_part_vals = drop_part_vals; this.deleteData = deleteData; setDeleteDataIsSet(true); } @@ -43918,7 +44141,7 @@ public drop_partition_args( /** * Performs a deep copy on other. */ - public drop_partition_args(drop_partition_args other) { + public add_drop_partitions_args(add_drop_partitions_args other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetDb_name()) { this.db_name = other.db_name; @@ -43926,25 +44149,37 @@ public drop_partition_args(drop_partition_args other) { if (other.isSetTbl_name()) { this.tbl_name = other.tbl_name; } - if (other.isSetPart_vals()) { - List __this__part_vals = new ArrayList(); - for (String other_element : other.part_vals) { - __this__part_vals.add(other_element); + if (other.isSetAdd_parts()) { + List __this__add_parts = new ArrayList(); + for (Partition other_element : other.add_parts) { + __this__add_parts.add(new Partition(other_element)); } - this.part_vals = __this__part_vals; + this.add_parts = __this__add_parts; + } + if (other.isSetDrop_part_vals()) { + List> __this__drop_part_vals = new ArrayList>(); + for (List other_element : other.drop_part_vals) { + List __this__drop_part_vals_copy = new ArrayList(); + for (String other_element_element : other_element) { + __this__drop_part_vals_copy.add(other_element_element); + } + __this__drop_part_vals.add(__this__drop_part_vals_copy); + } + this.drop_part_vals = __this__drop_part_vals; } this.deleteData = other.deleteData; } - public drop_partition_args deepCopy() { - return new drop_partition_args(this); + public add_drop_partitions_args deepCopy() { + return new add_drop_partitions_args(this); } @Override public void clear() { this.db_name = null; this.tbl_name = null; - this.part_vals = null; + this.add_parts = null; + this.drop_part_vals = null; setDeleteDataIsSet(false); this.deleteData = false; } @@ -43995,41 +44230,79 @@ public void setTbl_nameIsSet(boolean value) { } } - public int getPart_valsSize() { - return (this.part_vals == null) ? 0 : this.part_vals.size(); + public int getAdd_partsSize() { + return (this.add_parts == null) ? 0 : this.add_parts.size(); } - public java.util.Iterator getPart_valsIterator() { - return (this.part_vals == null) ? null : this.part_vals.iterator(); + public java.util.Iterator getAdd_partsIterator() { + return (this.add_parts == null) ? null : this.add_parts.iterator(); } - public void addToPart_vals(String elem) { - if (this.part_vals == null) { - this.part_vals = new ArrayList(); + public void addToAdd_parts(Partition elem) { + if (this.add_parts == null) { + this.add_parts = new ArrayList(); } - this.part_vals.add(elem); + this.add_parts.add(elem); } - public List getPart_vals() { - return this.part_vals; + public List getAdd_parts() { + return this.add_parts; } - public void setPart_vals(List part_vals) { - this.part_vals = part_vals; + public void setAdd_parts(List add_parts) { + this.add_parts = add_parts; } - public void unsetPart_vals() { - this.part_vals = null; + public void unsetAdd_parts() { + this.add_parts = null; } - /** Returns true if field part_vals is set (has been assigned a value) and false otherwise */ - public boolean isSetPart_vals() { - return this.part_vals != null; + /** Returns true if field add_parts is set (has been assigned a value) and false otherwise */ + public boolean isSetAdd_parts() { + return this.add_parts != null; } - public void setPart_valsIsSet(boolean value) { + public void setAdd_partsIsSet(boolean value) { if (!value) { - this.part_vals = null; + this.add_parts = null; + } + } + + public int getDrop_part_valsSize() { + return (this.drop_part_vals == null) ? 0 : this.drop_part_vals.size(); + } + + public java.util.Iterator> getDrop_part_valsIterator() { + return (this.drop_part_vals == null) ? null : this.drop_part_vals.iterator(); + } + + public void addToDrop_part_vals(List elem) { + if (this.drop_part_vals == null) { + this.drop_part_vals = new ArrayList>(); + } + this.drop_part_vals.add(elem); + } + + public List> getDrop_part_vals() { + return this.drop_part_vals; + } + + public void setDrop_part_vals(List> drop_part_vals) { + this.drop_part_vals = drop_part_vals; + } + + public void unsetDrop_part_vals() { + this.drop_part_vals = null; + } + + /** Returns true if field drop_part_vals is set (has been assigned a value) and false otherwise */ + public boolean isSetDrop_part_vals() { + return this.drop_part_vals != null; + } + + public void setDrop_part_valsIsSet(boolean value) { + if (!value) { + this.drop_part_vals = null; } } @@ -44073,11 +44346,19 @@ public void setFieldValue(_Fields field, Object value) { } break; - case PART_VALS: + case ADD_PARTS: if (value == null) { - unsetPart_vals(); + unsetAdd_parts(); } else { - setPart_vals((List)value); + setAdd_parts((List)value); + } + break; + + case DROP_PART_VALS: + if (value == null) { + unsetDrop_part_vals(); + } else { + setDrop_part_vals((List>)value); } break; @@ -44100,8 +44381,11 @@ public Object getFieldValue(_Fields field) { case TBL_NAME: return getTbl_name(); - case PART_VALS: - return getPart_vals(); + case ADD_PARTS: + return getAdd_parts(); + + case DROP_PART_VALS: + return getDrop_part_vals(); case DELETE_DATA: return Boolean.valueOf(isDeleteData()); @@ -44121,8 +44405,10 @@ public boolean isSet(_Fields field) { return isSetDb_name(); case TBL_NAME: return isSetTbl_name(); - case PART_VALS: - return isSetPart_vals(); + case ADD_PARTS: + return isSetAdd_parts(); + case DROP_PART_VALS: + return isSetDrop_part_vals(); case DELETE_DATA: return isSetDeleteData(); } @@ -44133,12 +44419,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_args) - return this.equals((drop_partition_args)that); + if (that instanceof add_drop_partitions_args) + return this.equals((add_drop_partitions_args)that); return false; } - public boolean equals(drop_partition_args that) { + public boolean equals(add_drop_partitions_args that) { if (that == null) return false; @@ -44160,12 +44446,21 @@ public boolean equals(drop_partition_args that) { return false; } - boolean this_present_part_vals = true && this.isSetPart_vals(); - boolean that_present_part_vals = true && that.isSetPart_vals(); - if (this_present_part_vals || that_present_part_vals) { - if (!(this_present_part_vals && that_present_part_vals)) + boolean this_present_add_parts = true && this.isSetAdd_parts(); + boolean that_present_add_parts = true && that.isSetAdd_parts(); + if (this_present_add_parts || that_present_add_parts) { + if (!(this_present_add_parts && that_present_add_parts)) return false; - if (!this.part_vals.equals(that.part_vals)) + if (!this.add_parts.equals(that.add_parts)) + return false; + } + + boolean this_present_drop_part_vals = true && this.isSetDrop_part_vals(); + boolean that_present_drop_part_vals = true && that.isSetDrop_part_vals(); + if (this_present_drop_part_vals || that_present_drop_part_vals) { + if (!(this_present_drop_part_vals && that_present_drop_part_vals)) + return false; + if (!this.drop_part_vals.equals(that.drop_part_vals)) return false; } @@ -44195,10 +44490,15 @@ public int hashCode() { if (present_tbl_name) builder.append(tbl_name); - boolean present_part_vals = true && (isSetPart_vals()); - builder.append(present_part_vals); - if (present_part_vals) - builder.append(part_vals); + boolean present_add_parts = true && (isSetAdd_parts()); + builder.append(present_add_parts); + if (present_add_parts) + builder.append(add_parts); + + boolean present_drop_part_vals = true && (isSetDrop_part_vals()); + builder.append(present_drop_part_vals); + if (present_drop_part_vals) + builder.append(drop_part_vals); boolean present_deleteData = true; builder.append(present_deleteData); @@ -44208,13 +44508,13 @@ public int hashCode() { return builder.toHashCode(); } - public int compareTo(drop_partition_args other) { + public int compareTo(add_drop_partitions_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_args typedOther = (drop_partition_args)other; + add_drop_partitions_args typedOther = (add_drop_partitions_args)other; lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); if (lastComparison != 0) { @@ -44236,12 +44536,22 @@ public int compareTo(drop_partition_args other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetPart_vals()).compareTo(typedOther.isSetPart_vals()); + lastComparison = Boolean.valueOf(isSetAdd_parts()).compareTo(typedOther.isSetAdd_parts()); if (lastComparison != 0) { return lastComparison; } - if (isSetPart_vals()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_vals, typedOther.part_vals); + if (isSetAdd_parts()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.add_parts, typedOther.add_parts); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDrop_part_vals()).compareTo(typedOther.isSetDrop_part_vals()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDrop_part_vals()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.drop_part_vals, typedOther.drop_part_vals); if (lastComparison != 0) { return lastComparison; } @@ -44273,7 +44583,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_args("); + StringBuilder sb = new StringBuilder("add_drop_partitions_args("); boolean first = true; sb.append("db_name:"); @@ -44292,11 +44602,19 @@ public String toString() { } first = false; if (!first) sb.append(", "); - sb.append("part_vals:"); - if (this.part_vals == null) { + sb.append("add_parts:"); + if (this.add_parts == null) { sb.append("null"); } else { - sb.append(this.part_vals); + sb.append(this.add_parts); + } + first = false; + if (!first) sb.append(", "); + sb.append("drop_part_vals:"); + if (this.drop_part_vals == null) { + sb.append("null"); + } else { + sb.append(this.drop_part_vals); } first = false; if (!first) sb.append(", "); @@ -44330,15 +44648,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_argsStandardSchemeFactory implements SchemeFactory { - public drop_partition_argsStandardScheme getScheme() { - return new drop_partition_argsStandardScheme(); + private static class add_drop_partitions_argsStandardSchemeFactory implements SchemeFactory { + public add_drop_partitions_argsStandardScheme getScheme() { + return new add_drop_partitions_argsStandardScheme(); } } - private static class drop_partition_argsStandardScheme extends StandardScheme { + private static class add_drop_partitions_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, add_drop_partitions_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -44364,25 +44682,54 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // PART_VALS + case 3: // ADD_PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { org.apache.thrift.protocol.TList _list548 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list548.size); + struct.add_parts = new ArrayList(_list548.size); for (int _i549 = 0; _i549 < _list548.size; ++_i549) { - String _elem550; // required - _elem550 = iprot.readString(); - struct.part_vals.add(_elem550); + Partition _elem550; // required + _elem550 = new Partition(); + _elem550.read(iprot); + struct.add_parts.add(_elem550); } iprot.readListEnd(); } - struct.setPart_valsIsSet(true); + struct.setAdd_partsIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 4: // DELETE_DATA + case 4: // DROP_PART_VALS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list551 = iprot.readListBegin(); + struct.drop_part_vals = new ArrayList>(_list551.size); + for (int _i552 = 0; _i552 < _list551.size; ++_i552) + { + List _elem553; // required + { + org.apache.thrift.protocol.TList _list554 = iprot.readListBegin(); + _elem553 = new ArrayList(_list554.size); + for (int _i555 = 0; _i555 < _list554.size; ++_i555) + { + String _elem556; // required + _elem556 = iprot.readString(); + _elem553.add(_elem556); + } + iprot.readListEnd(); + } + struct.drop_part_vals.add(_elem553); + } + iprot.readListEnd(); + } + struct.setDrop_part_valsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // DELETE_DATA if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { struct.deleteData = iprot.readBool(); struct.setDeleteDataIsSet(true); @@ -44399,7 +44746,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, add_drop_partitions_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -44413,13 +44760,32 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_arg oprot.writeString(struct.tbl_name); oprot.writeFieldEnd(); } - if (struct.part_vals != null) { - oprot.writeFieldBegin(PART_VALS_FIELD_DESC); + if (struct.add_parts != null) { + oprot.writeFieldBegin(ADD_PARTS_FIELD_DESC); { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.part_vals.size())); - for (String _iter551 : struct.part_vals) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.add_parts.size())); + for (Partition _iter557 : struct.add_parts) + { + _iter557.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.drop_part_vals != null) { + oprot.writeFieldBegin(DROP_PART_VALS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, struct.drop_part_vals.size())); + for (List _iter558 : struct.drop_part_vals) { - oprot.writeString(_iter551); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter558.size())); + for (String _iter559 : _iter558) + { + oprot.writeString(_iter559); + } + oprot.writeListEnd(); + } } oprot.writeListEnd(); } @@ -44434,16 +44800,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_arg } - private static class drop_partition_argsTupleSchemeFactory implements SchemeFactory { - public drop_partition_argsTupleScheme getScheme() { - return new drop_partition_argsTupleScheme(); + private static class add_drop_partitions_argsTupleSchemeFactory implements SchemeFactory { + public add_drop_partitions_argsTupleScheme getScheme() { + return new add_drop_partitions_argsTupleScheme(); } } - private static class drop_partition_argsTupleScheme extends TupleScheme { + private static class add_drop_partitions_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, add_drop_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetDb_name()) { @@ -44452,25 +44818,43 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args if (struct.isSetTbl_name()) { optionals.set(1); } - if (struct.isSetPart_vals()) { + if (struct.isSetAdd_parts()) { optionals.set(2); } - if (struct.isSetDeleteData()) { + if (struct.isSetDrop_part_vals()) { optionals.set(3); } - oprot.writeBitSet(optionals, 4); + if (struct.isSetDeleteData()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); if (struct.isSetDb_name()) { oprot.writeString(struct.db_name); } if (struct.isSetTbl_name()) { oprot.writeString(struct.tbl_name); } - if (struct.isSetPart_vals()) { + if (struct.isSetAdd_parts()) { { - oprot.writeI32(struct.part_vals.size()); - for (String _iter552 : struct.part_vals) + oprot.writeI32(struct.add_parts.size()); + for (Partition _iter560 : struct.add_parts) + { + _iter560.write(oprot); + } + } + } + if (struct.isSetDrop_part_vals()) { + { + oprot.writeI32(struct.drop_part_vals.size()); + for (List _iter561 : struct.drop_part_vals) { - oprot.writeString(_iter552); + { + oprot.writeI32(_iter561.size()); + for (String _iter562 : _iter561) + { + oprot.writeString(_iter562); + } + } } } } @@ -44480,9 +44864,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, add_drop_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); + BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { struct.db_name = iprot.readString(); struct.setDb_nameIsSet(true); @@ -44493,18 +44877,41 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list553 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list553.size); - for (int _i554 = 0; _i554 < _list553.size; ++_i554) + org.apache.thrift.protocol.TList _list563 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.add_parts = new ArrayList(_list563.size); + for (int _i564 = 0; _i564 < _list563.size; ++_i564) { - String _elem555; // required - _elem555 = iprot.readString(); - struct.part_vals.add(_elem555); + Partition _elem565; // required + _elem565 = new Partition(); + _elem565.read(iprot); + struct.add_parts.add(_elem565); } } - struct.setPart_valsIsSet(true); + struct.setAdd_partsIsSet(true); } if (incoming.get(3)) { + { + org.apache.thrift.protocol.TList _list566 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.drop_part_vals = new ArrayList>(_list566.size); + for (int _i567 = 0; _i567 < _list566.size; ++_i567) + { + List _elem568; // required + { + org.apache.thrift.protocol.TList _list569 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _elem568 = new ArrayList(_list569.size); + for (int _i570 = 0; _i570 < _list569.size; ++_i570) + { + String _elem571; // required + _elem571 = iprot.readString(); + _elem568.add(_elem571); + } + } + struct.drop_part_vals.add(_elem568); + } + } + struct.setDrop_part_valsIsSet(true); + } + if (incoming.get(4)) { struct.deleteData = iprot.readBool(); struct.setDeleteDataIsSet(true); } @@ -44513,28 +44920,34 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args } - public static class drop_partition_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_result"); + public static class add_drop_partitions_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("add_drop_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.BOOL, (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 drop_partition_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new add_drop_partitions_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new add_drop_partitions_resultTupleSchemeFactory()); } private boolean success; // required - private NoSuchObjectException o1; // required - private MetaException o2; // required + private InvalidObjectException o1; // required + private AlreadyExistsException o2; // required + private NoSuchObjectException o3; // required + private MetaException 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"); + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); private static final Map byName = new HashMap(); @@ -44555,6 +44968,10 @@ public static _Fields findByThriftId(int fieldId) { return O1; case 2: // O2 return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; default: return null; } @@ -44606,41 +45023,55 @@ public String getFieldName() { 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(drop_partition_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(add_drop_partitions_result.class, metaDataMap); } - public drop_partition_result() { + public add_drop_partitions_result() { } - public drop_partition_result( + public add_drop_partitions_result( boolean success, - NoSuchObjectException o1, - MetaException o2) + InvalidObjectException o1, + AlreadyExistsException o2, + NoSuchObjectException o3, + MetaException o4) { this(); this.success = success; setSuccessIsSet(true); this.o1 = o1; this.o2 = o2; + this.o3 = o3; + this.o4 = o4; } /** * Performs a deep copy on other. */ - public drop_partition_result(drop_partition_result other) { + public add_drop_partitions_result(add_drop_partitions_result other) { __isset_bitfield = other.__isset_bitfield; this.success = other.success; if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); + this.o1 = new InvalidObjectException(other.o1); } if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); + this.o2 = new AlreadyExistsException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new NoSuchObjectException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new MetaException(other.o4); } } - public drop_partition_result deepCopy() { - return new drop_partition_result(this); + public add_drop_partitions_result deepCopy() { + return new add_drop_partitions_result(this); } @Override @@ -44649,6 +45080,8 @@ public void clear() { this.success = false; this.o1 = null; this.o2 = null; + this.o3 = null; + this.o4 = null; } public boolean isSuccess() { @@ -44673,11 +45106,11 @@ public void setSuccessIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); } - public NoSuchObjectException getO1() { + public InvalidObjectException getO1() { return this.o1; } - public void setO1(NoSuchObjectException o1) { + public void setO1(InvalidObjectException o1) { this.o1 = o1; } @@ -44696,11 +45129,11 @@ public void setO1IsSet(boolean value) { } } - public MetaException getO2() { + public AlreadyExistsException getO2() { return this.o2; } - public void setO2(MetaException o2) { + public void setO2(AlreadyExistsException o2) { this.o2 = o2; } @@ -44719,6 +45152,52 @@ public void setO2IsSet(boolean value) { } } + public NoSuchObjectException getO3() { + return this.o3; + } + + public void setO3(NoSuchObjectException 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 MetaException getO4() { + return this.o4; + } + + public void setO4(MetaException 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: @@ -44733,7 +45212,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO1(); } else { - setO1((NoSuchObjectException)value); + setO1((InvalidObjectException)value); } break; @@ -44741,7 +45220,23 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetO2(); } else { - setO2((MetaException)value); + setO2((AlreadyExistsException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((NoSuchObjectException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((MetaException)value); } break; @@ -44759,6 +45254,12 @@ public Object getFieldValue(_Fields field) { case O2: return getO2(); + case O3: + return getO3(); + + case O4: + return getO4(); + } throw new IllegalStateException(); } @@ -44776,6 +45277,10 @@ public boolean isSet(_Fields field) { return isSetO1(); case O2: return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); } throw new IllegalStateException(); } @@ -44784,12 +45289,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_result) - return this.equals((drop_partition_result)that); + if (that instanceof add_drop_partitions_result) + return this.equals((add_drop_partitions_result)that); return false; } - public boolean equals(drop_partition_result that) { + public boolean equals(add_drop_partitions_result that) { if (that == null) return false; @@ -44820,6 +45325,24 @@ public boolean equals(drop_partition_result that) { 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; } @@ -44842,16 +45365,26 @@ public int hashCode() { if (present_o2) builder.append(o2); + boolean present_o3 = true && (isSetO3()); + builder.append(present_o3); + if (present_o3) + builder.append(o3); + + boolean present_o4 = true && (isSetO4()); + builder.append(present_o4); + if (present_o4) + builder.append(o4); + return builder.toHashCode(); } - public int compareTo(drop_partition_result other) { + public int compareTo(add_drop_partitions_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_result typedOther = (drop_partition_result)other; + add_drop_partitions_result typedOther = (add_drop_partitions_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -44883,6 +45416,26 @@ public int compareTo(drop_partition_result other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(typedOther.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, typedOther.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO4()).compareTo(typedOther.isSetO4()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO4()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o4, typedOther.o4); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -44900,7 +45453,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_result("); + StringBuilder sb = new StringBuilder("add_drop_partitions_result("); boolean first = true; sb.append("success:"); @@ -44922,6 +45475,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(); } @@ -44949,15 +45518,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_resultStandardSchemeFactory implements SchemeFactory { - public drop_partition_resultStandardScheme getScheme() { - return new drop_partition_resultStandardScheme(); + private static class add_drop_partitions_resultStandardSchemeFactory implements SchemeFactory { + public add_drop_partitions_resultStandardScheme getScheme() { + return new add_drop_partitions_resultStandardScheme(); } } - private static class drop_partition_resultStandardScheme extends StandardScheme { + private static class add_drop_partitions_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, add_drop_partitions_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -44977,7 +45546,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_resu break; case 1: // O1 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new InvalidObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } else { @@ -44986,13 +45555,31 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_resu break; case 2: // O2 if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.o2 = new MetaException(); + struct.o2 = new AlreadyExistsException(); struct.o2.read(iprot); struct.setO2IsSet(true); } else { 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 NoSuchObjectException(); + 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 MetaException(); + 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); } @@ -45002,7 +45589,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_resu struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, add_drop_partitions_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -45021,22 +45608,32 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_res 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 drop_partition_resultTupleSchemeFactory implements SchemeFactory { - public drop_partition_resultTupleScheme getScheme() { - return new drop_partition_resultTupleScheme(); + private static class add_drop_partitions_resultTupleSchemeFactory implements SchemeFactory { + public add_drop_partitions_resultTupleScheme getScheme() { + return new add_drop_partitions_resultTupleScheme(); } } - private static class drop_partition_resultTupleScheme extends TupleScheme { + private static class add_drop_partitions_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, add_drop_partitions_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -45048,7 +45645,13 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_resu 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()) { oprot.writeBool(struct.success); } @@ -45058,59 +45661,72 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_resu 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, drop_partition_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, add_drop_partitions_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 = iprot.readBool(); struct.setSuccessIsSet(true); } if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); + struct.o1 = new InvalidObjectException(); struct.o1.read(iprot); struct.setO1IsSet(true); } if (incoming.get(2)) { - struct.o2 = new MetaException(); + struct.o2 = new AlreadyExistsException(); struct.o2.read(iprot); struct.setO2IsSet(true); } + if (incoming.get(3)) { + struct.o3 = new NoSuchObjectException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + if (incoming.get(4)) { + struct.o4 = new MetaException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } } } } - public static class drop_partition_with_environment_context_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_with_environment_context_args"); + public static class drop_partitions_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partitions_args"); private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); private static final org.apache.thrift.protocol.TField PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("part_vals", org.apache.thrift.protocol.TType.LIST, (short)3); private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); - private static final org.apache.thrift.protocol.TField ENVIRONMENT_CONTEXT_FIELD_DESC = new org.apache.thrift.protocol.TField("environment_context", org.apache.thrift.protocol.TType.STRUCT, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_with_environment_context_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_with_environment_context_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_partitions_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partitions_argsTupleSchemeFactory()); } private String db_name; // required private String tbl_name; // required - private List part_vals; // required + private List> part_vals; // required private boolean deleteData; // required - private EnvironmentContext environment_context; // 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 { DB_NAME((short)1, "db_name"), TBL_NAME((short)2, "tbl_name"), PART_VALS((short)3, "part_vals"), - DELETE_DATA((short)4, "deleteData"), - ENVIRONMENT_CONTEXT((short)5, "environment_context"); + DELETE_DATA((short)4, "deleteData"); private static final Map byName = new HashMap(); @@ -45133,8 +45749,6 @@ public static _Fields findByThriftId(int fieldId) { return PART_VALS; case 4: // DELETE_DATA return DELETE_DATA; - case 5: // ENVIRONMENT_CONTEXT - return ENVIRONMENT_CONTEXT; default: return null; } @@ -45186,24 +45800,22 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))))); tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.ENVIRONMENT_CONTEXT, new org.apache.thrift.meta_data.FieldMetaData("environment_context", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, EnvironmentContext.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_with_environment_context_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partitions_args.class, metaDataMap); } - public drop_partition_with_environment_context_args() { + public drop_partitions_args() { } - public drop_partition_with_environment_context_args( + public drop_partitions_args( String db_name, String tbl_name, - List part_vals, - boolean deleteData, - EnvironmentContext environment_context) + List> part_vals, + boolean deleteData) { this(); this.db_name = db_name; @@ -45211,13 +45823,12 @@ public drop_partition_with_environment_context_args( this.part_vals = part_vals; this.deleteData = deleteData; setDeleteDataIsSet(true); - this.environment_context = environment_context; } /** * Performs a deep copy on other. */ - public drop_partition_with_environment_context_args(drop_partition_with_environment_context_args other) { + public drop_partitions_args(drop_partitions_args other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetDb_name()) { this.db_name = other.db_name; @@ -45226,20 +45837,21 @@ public drop_partition_with_environment_context_args(drop_partition_with_environm this.tbl_name = other.tbl_name; } if (other.isSetPart_vals()) { - List __this__part_vals = new ArrayList(); - for (String other_element : other.part_vals) { - __this__part_vals.add(other_element); + List> __this__part_vals = new ArrayList>(); + for (List other_element : other.part_vals) { + List __this__part_vals_copy = new ArrayList(); + for (String other_element_element : other_element) { + __this__part_vals_copy.add(other_element_element); + } + __this__part_vals.add(__this__part_vals_copy); } this.part_vals = __this__part_vals; } this.deleteData = other.deleteData; - if (other.isSetEnvironment_context()) { - this.environment_context = new EnvironmentContext(other.environment_context); - } } - public drop_partition_with_environment_context_args deepCopy() { - return new drop_partition_with_environment_context_args(this); + public drop_partitions_args deepCopy() { + return new drop_partitions_args(this); } @Override @@ -45249,7 +45861,6 @@ public void clear() { this.part_vals = null; setDeleteDataIsSet(false); this.deleteData = false; - this.environment_context = null; } public String getDb_name() { @@ -45302,22 +45913,22 @@ public int getPart_valsSize() { return (this.part_vals == null) ? 0 : this.part_vals.size(); } - public java.util.Iterator getPart_valsIterator() { + public java.util.Iterator> getPart_valsIterator() { return (this.part_vals == null) ? null : this.part_vals.iterator(); } - public void addToPart_vals(String elem) { + public void addToPart_vals(List elem) { if (this.part_vals == null) { - this.part_vals = new ArrayList(); + this.part_vals = new ArrayList>(); } this.part_vals.add(elem); } - public List getPart_vals() { + public List> getPart_vals() { return this.part_vals; } - public void setPart_vals(List part_vals) { + public void setPart_vals(List> part_vals) { this.part_vals = part_vals; } @@ -45358,29 +45969,6 @@ public void setDeleteDataIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DELETEDATA_ISSET_ID, value); } - public EnvironmentContext getEnvironment_context() { - return this.environment_context; - } - - public void setEnvironment_context(EnvironmentContext environment_context) { - this.environment_context = environment_context; - } - - public void unsetEnvironment_context() { - this.environment_context = null; - } - - /** Returns true if field environment_context is set (has been assigned a value) and false otherwise */ - public boolean isSetEnvironment_context() { - return this.environment_context != null; - } - - public void setEnvironment_contextIsSet(boolean value) { - if (!value) { - this.environment_context = null; - } - } - public void setFieldValue(_Fields field, Object value) { switch (field) { case DB_NAME: @@ -45403,7 +45991,7 @@ public void setFieldValue(_Fields field, Object value) { if (value == null) { unsetPart_vals(); } else { - setPart_vals((List)value); + setPart_vals((List>)value); } break; @@ -45415,14 +46003,6 @@ public void setFieldValue(_Fields field, Object value) { } break; - case ENVIRONMENT_CONTEXT: - if (value == null) { - unsetEnvironment_context(); - } else { - setEnvironment_context((EnvironmentContext)value); - } - break; - } } @@ -45440,9 +46020,6 @@ public Object getFieldValue(_Fields field) { case DELETE_DATA: return Boolean.valueOf(isDeleteData()); - case ENVIRONMENT_CONTEXT: - return getEnvironment_context(); - } throw new IllegalStateException(); } @@ -45462,8 +46039,6 @@ public boolean isSet(_Fields field) { return isSetPart_vals(); case DELETE_DATA: return isSetDeleteData(); - case ENVIRONMENT_CONTEXT: - return isSetEnvironment_context(); } throw new IllegalStateException(); } @@ -45472,12 +46047,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_with_environment_context_args) - return this.equals((drop_partition_with_environment_context_args)that); + if (that instanceof drop_partitions_args) + return this.equals((drop_partitions_args)that); return false; } - public boolean equals(drop_partition_with_environment_context_args that) { + public boolean equals(drop_partitions_args that) { if (that == null) return false; @@ -45517,15 +46092,6 @@ public boolean equals(drop_partition_with_environment_context_args that) { return false; } - boolean this_present_environment_context = true && this.isSetEnvironment_context(); - boolean that_present_environment_context = true && that.isSetEnvironment_context(); - if (this_present_environment_context || that_present_environment_context) { - if (!(this_present_environment_context && that_present_environment_context)) - return false; - if (!this.environment_context.equals(that.environment_context)) - return false; - } - return true; } @@ -45553,21 +46119,16 @@ public int hashCode() { if (present_deleteData) builder.append(deleteData); - boolean present_environment_context = true && (isSetEnvironment_context()); - builder.append(present_environment_context); - if (present_environment_context) - builder.append(environment_context); - return builder.toHashCode(); } - public int compareTo(drop_partition_with_environment_context_args other) { + public int compareTo(drop_partitions_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_with_environment_context_args typedOther = (drop_partition_with_environment_context_args)other; + drop_partitions_args typedOther = (drop_partitions_args)other; lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); if (lastComparison != 0) { @@ -45609,16 +46170,6 @@ public int compareTo(drop_partition_with_environment_context_args other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetEnvironment_context()).compareTo(typedOther.isSetEnvironment_context()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEnvironment_context()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.environment_context, typedOther.environment_context); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -45636,7 +46187,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_with_environment_context_args("); + StringBuilder sb = new StringBuilder("drop_partitions_args("); boolean first = true; sb.append("db_name:"); @@ -45666,14 +46217,6 @@ public String toString() { sb.append("deleteData:"); sb.append(this.deleteData); first = false; - if (!first) sb.append(", "); - sb.append("environment_context:"); - if (this.environment_context == null) { - sb.append("null"); - } else { - sb.append(this.environment_context); - } - first = false; sb.append(")"); return sb.toString(); } @@ -45681,9 +46224,6 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (environment_context != null) { - environment_context.validate(); - } } private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { @@ -45704,15 +46244,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_with_environment_context_argsStandardSchemeFactory implements SchemeFactory { - public drop_partition_with_environment_context_argsStandardScheme getScheme() { - return new drop_partition_with_environment_context_argsStandardScheme(); + private static class drop_partitions_argsStandardSchemeFactory implements SchemeFactory { + public drop_partitions_argsStandardScheme getScheme() { + return new drop_partitions_argsStandardScheme(); } } - private static class drop_partition_with_environment_context_argsStandardScheme extends StandardScheme { + private static class drop_partitions_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partitions_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -45741,13 +46281,23 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list556 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list556.size); - for (int _i557 = 0; _i557 < _list556.size; ++_i557) + org.apache.thrift.protocol.TList _list572 = iprot.readListBegin(); + struct.part_vals = new ArrayList>(_list572.size); + for (int _i573 = 0; _i573 < _list572.size; ++_i573) { - String _elem558; // required - _elem558 = iprot.readString(); - struct.part_vals.add(_elem558); + List _elem574; // required + { + org.apache.thrift.protocol.TList _list575 = iprot.readListBegin(); + _elem574 = new ArrayList(_list575.size); + for (int _i576 = 0; _i576 < _list575.size; ++_i576) + { + String _elem577; // required + _elem577 = iprot.readString(); + _elem574.add(_elem577); + } + iprot.readListEnd(); + } + struct.part_vals.add(_elem574); } iprot.readListEnd(); } @@ -45764,15 +46314,6 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 5: // ENVIRONMENT_CONTEXT - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.environment_context = new EnvironmentContext(); - struct.environment_context.read(iprot); - struct.setEnvironment_contextIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -45782,7 +46323,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partitions_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -45799,10 +46340,17 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit if (struct.part_vals != null) { 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 _iter559 : struct.part_vals) + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, struct.part_vals.size())); + for (List _iter578 : struct.part_vals) { - oprot.writeString(_iter559); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter578.size())); + for (String _iter579 : _iter578) + { + oprot.writeString(_iter579); + } + oprot.writeListEnd(); + } } oprot.writeListEnd(); } @@ -45811,27 +46359,22 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit oprot.writeFieldBegin(DELETE_DATA_FIELD_DESC); oprot.writeBool(struct.deleteData); oprot.writeFieldEnd(); - if (struct.environment_context != null) { - oprot.writeFieldBegin(ENVIRONMENT_CONTEXT_FIELD_DESC); - struct.environment_context.write(oprot); - oprot.writeFieldEnd(); - } oprot.writeFieldStop(); oprot.writeStructEnd(); } } - private static class drop_partition_with_environment_context_argsTupleSchemeFactory implements SchemeFactory { - public drop_partition_with_environment_context_argsTupleScheme getScheme() { - return new drop_partition_with_environment_context_argsTupleScheme(); + private static class drop_partitions_argsTupleSchemeFactory implements SchemeFactory { + public drop_partitions_argsTupleScheme getScheme() { + return new drop_partitions_argsTupleScheme(); } } - private static class drop_partition_with_environment_context_argsTupleScheme extends TupleScheme { + private static class drop_partitions_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetDb_name()) { @@ -45846,10 +46389,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetDeleteData()) { optionals.set(3); } - if (struct.isSetEnvironment_context()) { - optionals.set(4); - } - oprot.writeBitSet(optionals, 5); + oprot.writeBitSet(optionals, 4); if (struct.isSetDb_name()) { oprot.writeString(struct.db_name); } @@ -45859,24 +46399,27 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter560 : struct.part_vals) + for (List _iter580 : struct.part_vals) { - oprot.writeString(_iter560); + { + oprot.writeI32(_iter580.size()); + for (String _iter581 : _iter580) + { + oprot.writeString(_iter581); + } + } } } } if (struct.isSetDeleteData()) { oprot.writeBool(struct.deleteData); } - if (struct.isSetEnvironment_context()) { - struct.environment_context.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partitions_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(5); + BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { struct.db_name = iprot.readString(); struct.setDb_nameIsSet(true); @@ -45887,13 +46430,22 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list561 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list561.size); - for (int _i562 = 0; _i562 < _list561.size; ++_i562) + org.apache.thrift.protocol.TList _list582 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.part_vals = new ArrayList>(_list582.size); + for (int _i583 = 0; _i583 < _list582.size; ++_i583) { - String _elem563; // required - _elem563 = iprot.readString(); - struct.part_vals.add(_elem563); + List _elem584; // required + { + org.apache.thrift.protocol.TList _list585 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _elem584 = new ArrayList(_list585.size); + for (int _i586 = 0; _i586 < _list585.size; ++_i586) + { + String _elem587; // required + _elem587 = iprot.readString(); + _elem584.add(_elem587); + } + } + struct.part_vals.add(_elem584); } } struct.setPart_valsIsSet(true); @@ -45902,38 +46454,27 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_ struct.deleteData = iprot.readBool(); struct.setDeleteDataIsSet(true); } - if (incoming.get(4)) { - struct.environment_context = new EnvironmentContext(); - struct.environment_context.read(iprot); - struct.setEnvironment_contextIsSet(true); - } } } } - public static class drop_partition_with_environment_context_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_with_environment_context_result"); + public static class drop_partitions_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_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.BOOL, (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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_with_environment_context_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_with_environment_context_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_partitions_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partitions_resultTupleSchemeFactory()); } private boolean success; // required - private NoSuchObjectException o1; // required - private MetaException o2; // 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"); + SUCCESS((short)0, "success"); private static final Map byName = new HashMap(); @@ -45950,10 +46491,6 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 0: // SUCCESS return SUCCESS; - case 1: // O1 - return O1; - case 2: // O2 - return O2; default: return null; } @@ -46001,53 +46538,37 @@ public String getFieldName() { 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.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - 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))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_with_environment_context_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partitions_result.class, metaDataMap); } - public drop_partition_with_environment_context_result() { + public drop_partitions_result() { } - public drop_partition_with_environment_context_result( - boolean success, - NoSuchObjectException o1, - MetaException o2) + public drop_partitions_result( + boolean success) { this(); this.success = success; setSuccessIsSet(true); - this.o1 = o1; - this.o2 = o2; } /** * Performs a deep copy on other. */ - public drop_partition_with_environment_context_result(drop_partition_with_environment_context_result other) { + public drop_partitions_result(drop_partitions_result other) { __isset_bitfield = other.__isset_bitfield; this.success = other.success; - if (other.isSetO1()) { - this.o1 = new NoSuchObjectException(other.o1); - } - if (other.isSetO2()) { - this.o2 = new MetaException(other.o2); - } } - public drop_partition_with_environment_context_result deepCopy() { - return new drop_partition_with_environment_context_result(this); + public drop_partitions_result deepCopy() { + return new drop_partitions_result(this); } @Override public void clear() { setSuccessIsSet(false); this.success = false; - this.o1 = null; - this.o2 = null; } public boolean isSuccess() { @@ -46072,52 +46593,6 @@ public void setSuccessIsSet(boolean value) { __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); } - public NoSuchObjectException getO1() { - return this.o1; - } - - public void setO1(NoSuchObjectException 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 MetaException getO2() { - return this.o2; - } - - public void setO2(MetaException 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 void setFieldValue(_Fields field, Object value) { switch (field) { case SUCCESS: @@ -46128,22 +46603,6 @@ public void setFieldValue(_Fields field, Object value) { } break; - case O1: - if (value == null) { - unsetO1(); - } else { - setO1((NoSuchObjectException)value); - } - break; - - case O2: - if (value == null) { - unsetO2(); - } else { - setO2((MetaException)value); - } - break; - } } @@ -46152,12 +46611,6 @@ public Object getFieldValue(_Fields field) { case SUCCESS: return Boolean.valueOf(isSuccess()); - case O1: - return getO1(); - - case O2: - return getO2(); - } throw new IllegalStateException(); } @@ -46171,10 +46624,6 @@ public boolean isSet(_Fields field) { switch (field) { case SUCCESS: return isSetSuccess(); - case O1: - return isSetO1(); - case O2: - return isSetO2(); } throw new IllegalStateException(); } @@ -46183,12 +46632,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_with_environment_context_result) - return this.equals((drop_partition_with_environment_context_result)that); + if (that instanceof drop_partitions_result) + return this.equals((drop_partitions_result)that); return false; } - public boolean equals(drop_partition_with_environment_context_result that) { + public boolean equals(drop_partitions_result that) { if (that == null) return false; @@ -46201,24 +46650,6 @@ public boolean equals(drop_partition_with_environment_context_result that) { 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; - } - return true; } @@ -46231,26 +46662,16 @@ public int hashCode() { if (present_success) builder.append(success); - boolean present_o1 = true && (isSetO1()); - builder.append(present_o1); - if (present_o1) - builder.append(o1); - - boolean present_o2 = true && (isSetO2()); - builder.append(present_o2); - if (present_o2) - builder.append(o2); - return builder.toHashCode(); } - public int compareTo(drop_partition_with_environment_context_result other) { + public int compareTo(drop_partitions_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_with_environment_context_result typedOther = (drop_partition_with_environment_context_result)other; + drop_partitions_result typedOther = (drop_partitions_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -46262,26 +46683,6 @@ public int compareTo(drop_partition_with_environment_context_result other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetO1()).compareTo(typedOther.isSetO1()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetO1()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, typedOther.o1); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetO2()).compareTo(typedOther.isSetO2()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetO2()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, typedOther.o2); - if (lastComparison != 0) { - return lastComparison; - } - } return 0; } @@ -46299,28 +46700,12 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_with_environment_context_result("); + StringBuilder sb = new StringBuilder("drop_partitions_result("); boolean first = true; sb.append("success:"); 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(); } @@ -46348,15 +46733,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_with_environment_context_resultStandardSchemeFactory implements SchemeFactory { - public drop_partition_with_environment_context_resultStandardScheme getScheme() { - return new drop_partition_with_environment_context_resultStandardScheme(); + private static class drop_partitions_resultStandardSchemeFactory implements SchemeFactory { + public drop_partitions_resultStandardScheme getScheme() { + return new drop_partitions_resultStandardScheme(); } } - private static class drop_partition_with_environment_context_resultStandardScheme extends StandardScheme { + private static class drop_partitions_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partitions_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -46374,24 +46759,6 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with 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 NoSuchObjectException(); - 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 MetaException(); - 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); } @@ -46401,7 +46768,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partitions_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -46410,102 +46777,70 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_wit oprot.writeBool(struct.success); 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 drop_partition_with_environment_context_resultTupleSchemeFactory implements SchemeFactory { - public drop_partition_with_environment_context_resultTupleScheme getScheme() { - return new drop_partition_with_environment_context_resultTupleScheme(); + private static class drop_partitions_resultTupleSchemeFactory implements SchemeFactory { + public drop_partitions_resultTupleScheme getScheme() { + return new drop_partitions_resultTupleScheme(); } } - private static class drop_partition_with_environment_context_resultTupleScheme extends TupleScheme { + private static class drop_partitions_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partitions_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); + oprot.writeBitSet(optionals, 1); if (struct.isSetSuccess()) { oprot.writeBool(struct.success); } - if (struct.isSetO1()) { - struct.o1.write(oprot); - } - if (struct.isSetO2()) { - struct.o2.write(oprot); - } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partitions_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); + BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { struct.success = iprot.readBool(); struct.setSuccessIsSet(true); } - if (incoming.get(1)) { - struct.o1 = new NoSuchObjectException(); - struct.o1.read(iprot); - struct.setO1IsSet(true); - } - if (incoming.get(2)) { - struct.o2 = new MetaException(); - struct.o2.read(iprot); - struct.setO2IsSet(true); - } } } } - public static class drop_partition_by_name_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_args"); + public static class drop_partition_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_args"); private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PART_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("part_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("part_vals", org.apache.thrift.protocol.TType.LIST, (short)3); private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_by_name_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_by_name_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_partition_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_argsTupleSchemeFactory()); } private String db_name; // required private String tbl_name; // required - private String part_name; // required + private List part_vals; // required private boolean deleteData; // 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 { DB_NAME((short)1, "db_name"), TBL_NAME((short)2, "tbl_name"), - PART_NAME((short)3, "part_name"), + PART_VALS((short)3, "part_vals"), DELETE_DATA((short)4, "deleteData"); private static final Map byName = new HashMap(); @@ -46525,8 +46860,8 @@ public static _Fields findByThriftId(int fieldId) { return DB_NAME; case 2: // TBL_NAME return TBL_NAME; - case 3: // PART_NAME - return PART_NAME; + case 3: // PART_VALS + return PART_VALS; case 4: // DELETE_DATA return DELETE_DATA; default: @@ -46578,27 +46913,28 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tbl_name", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PART_NAME, new org.apache.thrift.meta_data.FieldMetaData("part_name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_args.class, metaDataMap); } - public drop_partition_by_name_args() { + public drop_partition_args() { } - public drop_partition_by_name_args( + public drop_partition_args( String db_name, String tbl_name, - String part_name, + List part_vals, boolean deleteData) { this(); this.db_name = db_name; this.tbl_name = tbl_name; - this.part_name = part_name; + this.part_vals = part_vals; this.deleteData = deleteData; setDeleteDataIsSet(true); } @@ -46606,7 +46942,7 @@ public drop_partition_by_name_args( /** * Performs a deep copy on other. */ - public drop_partition_by_name_args(drop_partition_by_name_args other) { + public drop_partition_args(drop_partition_args other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetDb_name()) { this.db_name = other.db_name; @@ -46614,21 +46950,25 @@ public drop_partition_by_name_args(drop_partition_by_name_args other) { if (other.isSetTbl_name()) { this.tbl_name = other.tbl_name; } - if (other.isSetPart_name()) { - this.part_name = other.part_name; + if (other.isSetPart_vals()) { + List __this__part_vals = new ArrayList(); + for (String other_element : other.part_vals) { + __this__part_vals.add(other_element); + } + this.part_vals = __this__part_vals; } this.deleteData = other.deleteData; } - public drop_partition_by_name_args deepCopy() { - return new drop_partition_by_name_args(this); + public drop_partition_args deepCopy() { + return new drop_partition_args(this); } @Override public void clear() { this.db_name = null; this.tbl_name = null; - this.part_name = null; + this.part_vals = null; setDeleteDataIsSet(false); this.deleteData = false; } @@ -46679,26 +47019,41 @@ public void setTbl_nameIsSet(boolean value) { } } - public String getPart_name() { - return this.part_name; + public int getPart_valsSize() { + return (this.part_vals == null) ? 0 : this.part_vals.size(); } - public void setPart_name(String part_name) { - this.part_name = part_name; + public java.util.Iterator getPart_valsIterator() { + return (this.part_vals == null) ? null : this.part_vals.iterator(); } - public void unsetPart_name() { - this.part_name = null; + public void addToPart_vals(String elem) { + if (this.part_vals == null) { + this.part_vals = new ArrayList(); + } + this.part_vals.add(elem); } - /** Returns true if field part_name is set (has been assigned a value) and false otherwise */ - public boolean isSetPart_name() { - return this.part_name != null; + public List getPart_vals() { + return this.part_vals; } - public void setPart_nameIsSet(boolean value) { + public void setPart_vals(List part_vals) { + this.part_vals = part_vals; + } + + public void unsetPart_vals() { + this.part_vals = null; + } + + /** Returns true if field part_vals is set (has been assigned a value) and false otherwise */ + public boolean isSetPart_vals() { + return this.part_vals != null; + } + + public void setPart_valsIsSet(boolean value) { if (!value) { - this.part_name = null; + this.part_vals = null; } } @@ -46742,11 +47097,11 @@ public void setFieldValue(_Fields field, Object value) { } break; - case PART_NAME: + case PART_VALS: if (value == null) { - unsetPart_name(); + unsetPart_vals(); } else { - setPart_name((String)value); + setPart_vals((List)value); } break; @@ -46769,8 +47124,8 @@ public Object getFieldValue(_Fields field) { case TBL_NAME: return getTbl_name(); - case PART_NAME: - return getPart_name(); + case PART_VALS: + return getPart_vals(); case DELETE_DATA: return Boolean.valueOf(isDeleteData()); @@ -46790,8 +47145,8 @@ public boolean isSet(_Fields field) { return isSetDb_name(); case TBL_NAME: return isSetTbl_name(); - case PART_NAME: - return isSetPart_name(); + case PART_VALS: + return isSetPart_vals(); case DELETE_DATA: return isSetDeleteData(); } @@ -46802,12 +47157,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_by_name_args) - return this.equals((drop_partition_by_name_args)that); + if (that instanceof drop_partition_args) + return this.equals((drop_partition_args)that); return false; } - public boolean equals(drop_partition_by_name_args that) { + public boolean equals(drop_partition_args that) { if (that == null) return false; @@ -46829,12 +47184,12 @@ public boolean equals(drop_partition_by_name_args that) { return false; } - boolean this_present_part_name = true && this.isSetPart_name(); - boolean that_present_part_name = true && that.isSetPart_name(); - if (this_present_part_name || that_present_part_name) { - if (!(this_present_part_name && that_present_part_name)) + boolean this_present_part_vals = true && this.isSetPart_vals(); + boolean that_present_part_vals = true && that.isSetPart_vals(); + if (this_present_part_vals || that_present_part_vals) { + if (!(this_present_part_vals && that_present_part_vals)) return false; - if (!this.part_name.equals(that.part_name)) + if (!this.part_vals.equals(that.part_vals)) return false; } @@ -46864,10 +47219,10 @@ public int hashCode() { if (present_tbl_name) builder.append(tbl_name); - boolean present_part_name = true && (isSetPart_name()); - builder.append(present_part_name); - if (present_part_name) - builder.append(part_name); + boolean present_part_vals = true && (isSetPart_vals()); + builder.append(present_part_vals); + if (present_part_vals) + builder.append(part_vals); boolean present_deleteData = true; builder.append(present_deleteData); @@ -46877,13 +47232,13 @@ public int hashCode() { return builder.toHashCode(); } - public int compareTo(drop_partition_by_name_args other) { + public int compareTo(drop_partition_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_by_name_args typedOther = (drop_partition_by_name_args)other; + drop_partition_args typedOther = (drop_partition_args)other; lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); if (lastComparison != 0) { @@ -46905,12 +47260,12 @@ public int compareTo(drop_partition_by_name_args other) { return lastComparison; } } - lastComparison = Boolean.valueOf(isSetPart_name()).compareTo(typedOther.isSetPart_name()); + lastComparison = Boolean.valueOf(isSetPart_vals()).compareTo(typedOther.isSetPart_vals()); if (lastComparison != 0) { return lastComparison; } - if (isSetPart_name()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_name, typedOther.part_name); + if (isSetPart_vals()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_vals, typedOther.part_vals); if (lastComparison != 0) { return lastComparison; } @@ -46942,7 +47297,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_by_name_args("); + StringBuilder sb = new StringBuilder("drop_partition_args("); boolean first = true; sb.append("db_name:"); @@ -46961,11 +47316,11 @@ public String toString() { } first = false; if (!first) sb.append(", "); - sb.append("part_name:"); - if (this.part_name == null) { + sb.append("part_vals:"); + if (this.part_vals == null) { sb.append("null"); } else { - sb.append(this.part_name); + sb.append(this.part_vals); } first = false; if (!first) sb.append(", "); @@ -46999,15 +47354,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_by_name_argsStandardSchemeFactory implements SchemeFactory { - public drop_partition_by_name_argsStandardScheme getScheme() { - return new drop_partition_by_name_argsStandardScheme(); + private static class drop_partition_argsStandardSchemeFactory implements SchemeFactory { + public drop_partition_argsStandardScheme getScheme() { + return new drop_partition_argsStandardScheme(); } } - private static class drop_partition_by_name_argsStandardScheme extends StandardScheme { + private static class drop_partition_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -47033,10 +47388,20 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_n org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; - case 3: // PART_NAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.part_name = iprot.readString(); - struct.setPart_nameIsSet(true); + case 3: // PART_VALS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list588 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list588.size); + for (int _i589 = 0; _i589 < _list588.size; ++_i589) + { + String _elem590; // required + _elem590 = iprot.readString(); + struct.part_vals.add(_elem590); + } + iprot.readListEnd(); + } + struct.setPart_valsIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -47058,7 +47423,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_n struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -47072,9 +47437,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_by_ oprot.writeString(struct.tbl_name); oprot.writeFieldEnd(); } - if (struct.part_name != null) { - oprot.writeFieldBegin(PART_NAME_FIELD_DESC); - oprot.writeString(struct.part_name); + if (struct.part_vals != null) { + 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 _iter591 : struct.part_vals) + { + oprot.writeString(_iter591); + } + oprot.writeListEnd(); + } oprot.writeFieldEnd(); } oprot.writeFieldBegin(DELETE_DATA_FIELD_DESC); @@ -47086,16 +47458,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_by_ } - private static class drop_partition_by_name_argsTupleSchemeFactory implements SchemeFactory { - public drop_partition_by_name_argsTupleScheme getScheme() { - return new drop_partition_by_name_argsTupleScheme(); + private static class drop_partition_argsTupleSchemeFactory implements SchemeFactory { + public drop_partition_argsTupleScheme getScheme() { + return new drop_partition_argsTupleScheme(); } } - private static class drop_partition_by_name_argsTupleScheme extends TupleScheme { + private static class drop_partition_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetDb_name()) { @@ -47104,7 +47476,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_n if (struct.isSetTbl_name()) { optionals.set(1); } - if (struct.isSetPart_name()) { + if (struct.isSetPart_vals()) { optionals.set(2); } if (struct.isSetDeleteData()) { @@ -47117,8 +47489,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_n if (struct.isSetTbl_name()) { oprot.writeString(struct.tbl_name); } - if (struct.isSetPart_name()) { - oprot.writeString(struct.part_name); + if (struct.isSetPart_vals()) { + { + oprot.writeI32(struct.part_vals.size()); + for (String _iter592 : struct.part_vals) + { + oprot.writeString(_iter592); + } + } } if (struct.isSetDeleteData()) { oprot.writeBool(struct.deleteData); @@ -47126,7 +47504,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_n } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { @@ -47138,8 +47516,17 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_na struct.setTbl_nameIsSet(true); } if (incoming.get(2)) { - struct.part_name = iprot.readString(); - struct.setPart_nameIsSet(true); + { + org.apache.thrift.protocol.TList _list593 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list593.size); + for (int _i594 = 0; _i594 < _list593.size; ++_i594) + { + String _elem595; // required + _elem595 = iprot.readString(); + struct.part_vals.add(_elem595); + } + } + struct.setPart_valsIsSet(true); } if (incoming.get(3)) { struct.deleteData = iprot.readBool(); @@ -47150,8 +47537,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_na } - public static class drop_partition_by_name_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_result"); + public static class drop_partition_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_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.BOOL, (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); @@ -47159,8 +47546,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_na private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_by_name_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_by_name_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_partition_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_resultTupleSchemeFactory()); } private boolean success; // required @@ -47244,13 +47631,13 @@ public String getFieldName() { 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))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_result.class, metaDataMap); } - public drop_partition_by_name_result() { + public drop_partition_result() { } - public drop_partition_by_name_result( + public drop_partition_result( boolean success, NoSuchObjectException o1, MetaException o2) @@ -47265,7 +47652,7 @@ public drop_partition_by_name_result( /** * Performs a deep copy on other. */ - public drop_partition_by_name_result(drop_partition_by_name_result other) { + public drop_partition_result(drop_partition_result other) { __isset_bitfield = other.__isset_bitfield; this.success = other.success; if (other.isSetO1()) { @@ -47276,8 +47663,8 @@ public drop_partition_by_name_result(drop_partition_by_name_result other) { } } - public drop_partition_by_name_result deepCopy() { - return new drop_partition_by_name_result(this); + public drop_partition_result deepCopy() { + return new drop_partition_result(this); } @Override @@ -47421,12 +47808,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_by_name_result) - return this.equals((drop_partition_by_name_result)that); + if (that instanceof drop_partition_result) + return this.equals((drop_partition_result)that); return false; } - public boolean equals(drop_partition_by_name_result that) { + public boolean equals(drop_partition_result that) { if (that == null) return false; @@ -47482,13 +47869,13 @@ public int hashCode() { return builder.toHashCode(); } - public int compareTo(drop_partition_by_name_result other) { + public int compareTo(drop_partition_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_by_name_result typedOther = (drop_partition_by_name_result)other; + drop_partition_result typedOther = (drop_partition_result)other; lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); if (lastComparison != 0) { @@ -47537,7 +47924,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("drop_partition_by_name_result("); + StringBuilder sb = new StringBuilder("drop_partition_result("); boolean first = true; sb.append("success:"); @@ -47586,15 +47973,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class drop_partition_by_name_resultStandardSchemeFactory implements SchemeFactory { - public drop_partition_by_name_resultStandardScheme getScheme() { - return new drop_partition_by_name_resultStandardScheme(); + private static class drop_partition_resultStandardSchemeFactory implements SchemeFactory { + public drop_partition_resultStandardScheme getScheme() { + return new drop_partition_resultStandardScheme(); } } - private static class drop_partition_by_name_resultStandardScheme extends StandardScheme { + private static class drop_partition_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -47639,7 +48026,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_n struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -47664,16 +48051,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, drop_partition_by_ } - private static class drop_partition_by_name_resultTupleSchemeFactory implements SchemeFactory { - public drop_partition_by_name_resultTupleScheme getScheme() { - return new drop_partition_by_name_resultTupleScheme(); + private static class drop_partition_resultTupleSchemeFactory implements SchemeFactory { + public drop_partition_resultTupleScheme getScheme() { + return new drop_partition_resultTupleScheme(); } } - private static class drop_partition_by_name_resultTupleScheme extends TupleScheme { + private static class drop_partition_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -47698,7 +48085,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_n } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { @@ -47720,24 +48107,24 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_na } - public static class drop_partition_by_name_with_environment_context_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_with_environment_context_args"); + public static class drop_partition_with_environment_context_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_with_environment_context_args"); private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PART_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("part_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField PART_VALS_FIELD_DESC = new org.apache.thrift.protocol.TField("part_vals", org.apache.thrift.protocol.TType.LIST, (short)3); private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); private static final org.apache.thrift.protocol.TField ENVIRONMENT_CONTEXT_FIELD_DESC = new org.apache.thrift.protocol.TField("environment_context", org.apache.thrift.protocol.TType.STRUCT, (short)5); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new drop_partition_by_name_with_environment_context_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new drop_partition_by_name_with_environment_context_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new drop_partition_with_environment_context_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_with_environment_context_argsTupleSchemeFactory()); } private String db_name; // required private String tbl_name; // required - private String part_name; // required + private List part_vals; // required private boolean deleteData; // required private EnvironmentContext environment_context; // required @@ -47745,7 +48132,7 @@ public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_na public enum _Fields implements org.apache.thrift.TFieldIdEnum { DB_NAME((short)1, "db_name"), TBL_NAME((short)2, "tbl_name"), - PART_NAME((short)3, "part_name"), + PART_VALS((short)3, "part_vals"), DELETE_DATA((short)4, "deleteData"), ENVIRONMENT_CONTEXT((short)5, "environment_context"); @@ -47766,8 +48153,8 @@ public static _Fields findByThriftId(int fieldId) { return DB_NAME; case 2: // TBL_NAME return TBL_NAME; - case 3: // PART_NAME - return PART_NAME; + case 3: // PART_VALS + return PART_VALS; case 4: // DELETE_DATA return DELETE_DATA; case 5: // ENVIRONMENT_CONTEXT @@ -47821,30 +48208,31 @@ public String getFieldName() { new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tbl_name", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PART_NAME, new org.apache.thrift.meta_data.FieldMetaData("part_name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PART_VALS, new org.apache.thrift.meta_data.FieldMetaData("part_vals", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); tmpMap.put(_Fields.ENVIRONMENT_CONTEXT, new org.apache.thrift.meta_data.FieldMetaData("environment_context", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, EnvironmentContext.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_with_environment_context_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_with_environment_context_args.class, metaDataMap); } - public drop_partition_by_name_with_environment_context_args() { + public drop_partition_with_environment_context_args() { } - public drop_partition_by_name_with_environment_context_args( + public drop_partition_with_environment_context_args( String db_name, String tbl_name, - String part_name, + List part_vals, boolean deleteData, EnvironmentContext environment_context) { this(); this.db_name = db_name; this.tbl_name = tbl_name; - this.part_name = part_name; + this.part_vals = part_vals; this.deleteData = deleteData; setDeleteDataIsSet(true); this.environment_context = environment_context; @@ -47853,7 +48241,7 @@ public drop_partition_by_name_with_environment_context_args( /** * Performs a deep copy on other. */ - public drop_partition_by_name_with_environment_context_args(drop_partition_by_name_with_environment_context_args other) { + public drop_partition_with_environment_context_args(drop_partition_with_environment_context_args other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetDb_name()) { this.db_name = other.db_name; @@ -47861,8 +48249,12 @@ public drop_partition_by_name_with_environment_context_args(drop_partition_by_na if (other.isSetTbl_name()) { this.tbl_name = other.tbl_name; } - if (other.isSetPart_name()) { - this.part_name = other.part_name; + if (other.isSetPart_vals()) { + List __this__part_vals = new ArrayList(); + for (String other_element : other.part_vals) { + __this__part_vals.add(other_element); + } + this.part_vals = __this__part_vals; } this.deleteData = other.deleteData; if (other.isSetEnvironment_context()) { @@ -47870,15 +48262,15 @@ public drop_partition_by_name_with_environment_context_args(drop_partition_by_na } } - public drop_partition_by_name_with_environment_context_args deepCopy() { - return new drop_partition_by_name_with_environment_context_args(this); + public drop_partition_with_environment_context_args deepCopy() { + return new drop_partition_with_environment_context_args(this); } @Override public void clear() { this.db_name = null; this.tbl_name = null; - this.part_name = null; + this.part_vals = null; setDeleteDataIsSet(false); this.deleteData = false; this.environment_context = null; @@ -47930,26 +48322,41 @@ public void setTbl_nameIsSet(boolean value) { } } - public String getPart_name() { - return this.part_name; + public int getPart_valsSize() { + return (this.part_vals == null) ? 0 : this.part_vals.size(); } - public void setPart_name(String part_name) { - this.part_name = part_name; + public java.util.Iterator getPart_valsIterator() { + return (this.part_vals == null) ? null : this.part_vals.iterator(); } - public void unsetPart_name() { - this.part_name = null; + public void addToPart_vals(String elem) { + if (this.part_vals == null) { + this.part_vals = new ArrayList(); + } + this.part_vals.add(elem); } - /** Returns true if field part_name is set (has been assigned a value) and false otherwise */ - public boolean isSetPart_name() { - return this.part_name != null; + public List getPart_vals() { + return this.part_vals; } - public void setPart_nameIsSet(boolean value) { + public void setPart_vals(List part_vals) { + this.part_vals = part_vals; + } + + public void unsetPart_vals() { + this.part_vals = null; + } + + /** Returns true if field part_vals is set (has been assigned a value) and false otherwise */ + public boolean isSetPart_vals() { + return this.part_vals != null; + } + + public void setPart_valsIsSet(boolean value) { if (!value) { - this.part_name = null; + this.part_vals = null; } } @@ -48016,11 +48423,11 @@ public void setFieldValue(_Fields field, Object value) { } break; - case PART_NAME: + case PART_VALS: if (value == null) { - unsetPart_name(); + unsetPart_vals(); } else { - setPart_name((String)value); + setPart_vals((List)value); } break; @@ -48051,8 +48458,8 @@ public Object getFieldValue(_Fields field) { case TBL_NAME: return getTbl_name(); - case PART_NAME: - return getPart_name(); + case PART_VALS: + return getPart_vals(); case DELETE_DATA: return Boolean.valueOf(isDeleteData()); @@ -48075,8 +48482,8 @@ public boolean isSet(_Fields field) { return isSetDb_name(); case TBL_NAME: return isSetTbl_name(); - case PART_NAME: - return isSetPart_name(); + case PART_VALS: + return isSetPart_vals(); case DELETE_DATA: return isSetDeleteData(); case ENVIRONMENT_CONTEXT: @@ -48089,12 +48496,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof drop_partition_by_name_with_environment_context_args) - return this.equals((drop_partition_by_name_with_environment_context_args)that); + if (that instanceof drop_partition_with_environment_context_args) + return this.equals((drop_partition_with_environment_context_args)that); return false; } - public boolean equals(drop_partition_by_name_with_environment_context_args that) { + public boolean equals(drop_partition_with_environment_context_args that) { if (that == null) return false; @@ -48116,12 +48523,12 @@ public boolean equals(drop_partition_by_name_with_environment_context_args that) return false; } - boolean this_present_part_name = true && this.isSetPart_name(); - boolean that_present_part_name = true && that.isSetPart_name(); - if (this_present_part_name || that_present_part_name) { - if (!(this_present_part_name && that_present_part_name)) + boolean this_present_part_vals = true && this.isSetPart_vals(); + boolean that_present_part_vals = true && that.isSetPart_vals(); + if (this_present_part_vals || that_present_part_vals) { + if (!(this_present_part_vals && that_present_part_vals)) return false; - if (!this.part_name.equals(that.part_name)) + if (!this.part_vals.equals(that.part_vals)) return false; } @@ -48160,10 +48567,10 @@ public int hashCode() { if (present_tbl_name) builder.append(tbl_name); - boolean present_part_name = true && (isSetPart_name()); - builder.append(present_part_name); - if (present_part_name) - builder.append(part_name); + boolean present_part_vals = true && (isSetPart_vals()); + builder.append(present_part_vals); + if (present_part_vals) + builder.append(part_vals); boolean present_deleteData = true; builder.append(present_deleteData); @@ -48178,13 +48585,2630 @@ public int hashCode() { return builder.toHashCode(); } - public int compareTo(drop_partition_by_name_with_environment_context_args other) { + public int compareTo(drop_partition_with_environment_context_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - drop_partition_by_name_with_environment_context_args typedOther = (drop_partition_by_name_with_environment_context_args)other; + drop_partition_with_environment_context_args typedOther = (drop_partition_with_environment_context_args)other; + + lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDb_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.db_name, typedOther.db_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTbl_name()).compareTo(typedOther.isSetTbl_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTbl_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tbl_name, typedOther.tbl_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPart_vals()).compareTo(typedOther.isSetPart_vals()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPart_vals()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_vals, typedOther.part_vals); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDeleteData()).compareTo(typedOther.isSetDeleteData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDeleteData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteData, typedOther.deleteData); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEnvironment_context()).compareTo(typedOther.isSetEnvironment_context()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEnvironment_context()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.environment_context, typedOther.environment_context); + 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("drop_partition_with_environment_context_args("); + boolean first = true; + + sb.append("db_name:"); + if (this.db_name == null) { + sb.append("null"); + } else { + sb.append(this.db_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("tbl_name:"); + if (this.tbl_name == null) { + sb.append("null"); + } else { + sb.append(this.tbl_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("part_vals:"); + if (this.part_vals == null) { + sb.append("null"); + } else { + sb.append(this.part_vals); + } + first = false; + if (!first) sb.append(", "); + sb.append("deleteData:"); + sb.append(this.deleteData); + first = false; + if (!first) sb.append(", "); + sb.append("environment_context:"); + if (this.environment_context == null) { + sb.append("null"); + } else { + sb.append(this.environment_context); + } + 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 (environment_context != null) { + environment_context.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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + 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 drop_partition_with_environment_context_argsStandardSchemeFactory implements SchemeFactory { + public drop_partition_with_environment_context_argsStandardScheme getScheme() { + return new drop_partition_with_environment_context_argsStandardScheme(); + } + } + + private static class drop_partition_with_environment_context_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with_environment_context_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: // DB_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TBL_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tbl_name = iprot.readString(); + struct.setTbl_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PART_VALS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list596 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list596.size); + for (int _i597 = 0; _i597 < _list596.size; ++_i597) + { + String _elem598; // required + _elem598 = iprot.readString(); + struct.part_vals.add(_elem598); + } + iprot.readListEnd(); + } + struct.setPart_valsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DELETE_DATA + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.deleteData = iprot.readBool(); + struct.setDeleteDataIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // ENVIRONMENT_CONTEXT + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.environment_context = new EnvironmentContext(); + struct.environment_context.read(iprot); + struct.setEnvironment_contextIsSet(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, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.db_name != null) { + oprot.writeFieldBegin(DB_NAME_FIELD_DESC); + oprot.writeString(struct.db_name); + oprot.writeFieldEnd(); + } + if (struct.tbl_name != null) { + oprot.writeFieldBegin(TBL_NAME_FIELD_DESC); + oprot.writeString(struct.tbl_name); + oprot.writeFieldEnd(); + } + if (struct.part_vals != null) { + 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 _iter599 : struct.part_vals) + { + oprot.writeString(_iter599); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(DELETE_DATA_FIELD_DESC); + oprot.writeBool(struct.deleteData); + oprot.writeFieldEnd(); + if (struct.environment_context != null) { + oprot.writeFieldBegin(ENVIRONMENT_CONTEXT_FIELD_DESC); + struct.environment_context.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class drop_partition_with_environment_context_argsTupleSchemeFactory implements SchemeFactory { + public drop_partition_with_environment_context_argsTupleScheme getScheme() { + return new drop_partition_with_environment_context_argsTupleScheme(); + } + } + + private static class drop_partition_with_environment_context_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDb_name()) { + optionals.set(0); + } + if (struct.isSetTbl_name()) { + optionals.set(1); + } + if (struct.isSetPart_vals()) { + optionals.set(2); + } + if (struct.isSetDeleteData()) { + optionals.set(3); + } + if (struct.isSetEnvironment_context()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetDb_name()) { + oprot.writeString(struct.db_name); + } + if (struct.isSetTbl_name()) { + oprot.writeString(struct.tbl_name); + } + if (struct.isSetPart_vals()) { + { + oprot.writeI32(struct.part_vals.size()); + for (String _iter600 : struct.part_vals) + { + oprot.writeString(_iter600); + } + } + } + if (struct.isSetDeleteData()) { + oprot.writeBool(struct.deleteData); + } + if (struct.isSetEnvironment_context()) { + struct.environment_context.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + } + if (incoming.get(1)) { + struct.tbl_name = iprot.readString(); + struct.setTbl_nameIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list601 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list601.size); + for (int _i602 = 0; _i602 < _list601.size; ++_i602) + { + String _elem603; // required + _elem603 = iprot.readString(); + struct.part_vals.add(_elem603); + } + } + struct.setPart_valsIsSet(true); + } + if (incoming.get(3)) { + struct.deleteData = iprot.readBool(); + struct.setDeleteDataIsSet(true); + } + if (incoming.get(4)) { + struct.environment_context = new EnvironmentContext(); + struct.environment_context.read(iprot); + struct.setEnvironment_contextIsSet(true); + } + } + } + + } + + public static class drop_partition_with_environment_context_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_with_environment_context_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_partition_with_environment_context_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_with_environment_context_resultTupleSchemeFactory()); + } + + private boolean success; // required + private NoSuchObjectException o1; // required + private MetaException o2; // 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"); + + 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; + 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 + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_with_environment_context_result.class, metaDataMap); + } + + public drop_partition_with_environment_context_result() { + } + + public drop_partition_with_environment_context_result( + boolean success, + NoSuchObjectException o1, + MetaException o2) + { + this(); + this.success = success; + setSuccessIsSet(true); + this.o1 = o1; + this.o2 = o2; + } + + /** + * Performs a deep copy on other. + */ + public drop_partition_with_environment_context_result(drop_partition_with_environment_context_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new MetaException(other.o2); + } + } + + public drop_partition_with_environment_context_result deepCopy() { + return new drop_partition_with_environment_context_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + this.o1 = null; + this.o2 = null; + } + + public boolean isSuccess() { + return this.success; + } + + public void setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + } + + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public NoSuchObjectException getO1() { + return this.o1; + } + + public void setO1(NoSuchObjectException 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 MetaException getO2() { + return this.o2; + } + + public void setO2(MetaException 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 void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return Boolean.valueOf(isSuccess()); + + case O1: + return getO1(); + + case O2: + return getO2(); + + } + 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(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_partition_with_environment_context_result) + return this.equals((drop_partition_with_environment_context_result)that); + return false; + } + + public boolean equals(drop_partition_with_environment_context_result that) { + if (that == null) + return false; + + boolean this_present_success = true; + boolean that_present_success = true; + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (this.success != 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; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_success = true; + builder.append(present_success); + if (present_success) + builder.append(success); + + boolean present_o1 = true && (isSetO1()); + builder.append(present_o1); + if (present_o1) + builder.append(o1); + + boolean present_o2 = true && (isSetO2()); + builder.append(present_o2); + if (present_o2) + builder.append(o2); + + return builder.toHashCode(); + } + + public int compareTo(drop_partition_with_environment_context_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + drop_partition_with_environment_context_result typedOther = (drop_partition_with_environment_context_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(typedOther.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, typedOther.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(typedOther.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, typedOther.o2); + 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("drop_partition_with_environment_context_result("); + boolean first = true; + + sb.append("success:"); + 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 + } + + 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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + 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 drop_partition_with_environment_context_resultStandardSchemeFactory implements SchemeFactory { + public drop_partition_with_environment_context_resultStandardScheme getScheme() { + return new drop_partition_with_environment_context_resultStandardScheme(); + } + } + + private static class drop_partition_with_environment_context_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_with_environment_context_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.BOOL) { + struct.success = iprot.readBool(); + 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 NoSuchObjectException(); + 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 MetaException(); + 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, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + 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 drop_partition_with_environment_context_resultTupleSchemeFactory implements SchemeFactory { + public drop_partition_with_environment_context_resultTupleScheme getScheme() { + return new drop_partition_with_environment_context_resultTupleScheme(); + } + } + + private static class drop_partition_with_environment_context_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_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()) { + oprot.writeBool(struct.success); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_with_environment_context_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new MetaException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + } + } + + } + + public static class drop_partition_by_name_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_args"); + + private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PART_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("part_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_partition_by_name_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_by_name_argsTupleSchemeFactory()); + } + + private String db_name; // required + private String tbl_name; // required + private String part_name; // required + private boolean deleteData; // 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 { + DB_NAME((short)1, "db_name"), + TBL_NAME((short)2, "tbl_name"), + PART_NAME((short)3, "part_name"), + DELETE_DATA((short)4, "deleteData"); + + 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: // DB_NAME + return DB_NAME; + case 2: // TBL_NAME + return TBL_NAME; + case 3: // PART_NAME + return PART_NAME; + case 4: // DELETE_DATA + return DELETE_DATA; + 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 + private static final int __DELETEDATA_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("db_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tbl_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PART_NAME, new org.apache.thrift.meta_data.FieldMetaData("part_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_args.class, metaDataMap); + } + + public drop_partition_by_name_args() { + } + + public drop_partition_by_name_args( + String db_name, + String tbl_name, + String part_name, + boolean deleteData) + { + this(); + this.db_name = db_name; + this.tbl_name = tbl_name; + this.part_name = part_name; + this.deleteData = deleteData; + setDeleteDataIsSet(true); + } + + /** + * Performs a deep copy on other. + */ + public drop_partition_by_name_args(drop_partition_by_name_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDb_name()) { + this.db_name = other.db_name; + } + if (other.isSetTbl_name()) { + this.tbl_name = other.tbl_name; + } + if (other.isSetPart_name()) { + this.part_name = other.part_name; + } + this.deleteData = other.deleteData; + } + + public drop_partition_by_name_args deepCopy() { + return new drop_partition_by_name_args(this); + } + + @Override + public void clear() { + this.db_name = null; + this.tbl_name = null; + this.part_name = null; + setDeleteDataIsSet(false); + this.deleteData = false; + } + + public String getDb_name() { + return this.db_name; + } + + public void setDb_name(String db_name) { + this.db_name = db_name; + } + + public void unsetDb_name() { + this.db_name = null; + } + + /** Returns true if field db_name is set (has been assigned a value) and false otherwise */ + public boolean isSetDb_name() { + return this.db_name != null; + } + + public void setDb_nameIsSet(boolean value) { + if (!value) { + this.db_name = null; + } + } + + public String getTbl_name() { + return this.tbl_name; + } + + public void setTbl_name(String tbl_name) { + this.tbl_name = tbl_name; + } + + public void unsetTbl_name() { + this.tbl_name = null; + } + + /** Returns true if field tbl_name is set (has been assigned a value) and false otherwise */ + public boolean isSetTbl_name() { + return this.tbl_name != null; + } + + public void setTbl_nameIsSet(boolean value) { + if (!value) { + this.tbl_name = null; + } + } + + public String getPart_name() { + return this.part_name; + } + + public void setPart_name(String part_name) { + this.part_name = part_name; + } + + public void unsetPart_name() { + this.part_name = null; + } + + /** Returns true if field part_name is set (has been assigned a value) and false otherwise */ + public boolean isSetPart_name() { + return this.part_name != null; + } + + public void setPart_nameIsSet(boolean value) { + if (!value) { + this.part_name = null; + } + } + + public boolean isDeleteData() { + return this.deleteData; + } + + public void setDeleteData(boolean deleteData) { + this.deleteData = deleteData; + setDeleteDataIsSet(true); + } + + public void unsetDeleteData() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DELETEDATA_ISSET_ID); + } + + /** Returns true if field deleteData is set (has been assigned a value) and false otherwise */ + public boolean isSetDeleteData() { + return EncodingUtils.testBit(__isset_bitfield, __DELETEDATA_ISSET_ID); + } + + public void setDeleteDataIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DELETEDATA_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DB_NAME: + if (value == null) { + unsetDb_name(); + } else { + setDb_name((String)value); + } + break; + + case TBL_NAME: + if (value == null) { + unsetTbl_name(); + } else { + setTbl_name((String)value); + } + break; + + case PART_NAME: + if (value == null) { + unsetPart_name(); + } else { + setPart_name((String)value); + } + break; + + case DELETE_DATA: + if (value == null) { + unsetDeleteData(); + } else { + setDeleteData((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DB_NAME: + return getDb_name(); + + case TBL_NAME: + return getTbl_name(); + + case PART_NAME: + return getPart_name(); + + case DELETE_DATA: + return Boolean.valueOf(isDeleteData()); + + } + 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 DB_NAME: + return isSetDb_name(); + case TBL_NAME: + return isSetTbl_name(); + case PART_NAME: + return isSetPart_name(); + case DELETE_DATA: + return isSetDeleteData(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_partition_by_name_args) + return this.equals((drop_partition_by_name_args)that); + return false; + } + + public boolean equals(drop_partition_by_name_args that) { + if (that == null) + return false; + + boolean this_present_db_name = true && this.isSetDb_name(); + boolean that_present_db_name = true && that.isSetDb_name(); + if (this_present_db_name || that_present_db_name) { + if (!(this_present_db_name && that_present_db_name)) + return false; + if (!this.db_name.equals(that.db_name)) + return false; + } + + boolean this_present_tbl_name = true && this.isSetTbl_name(); + boolean that_present_tbl_name = true && that.isSetTbl_name(); + if (this_present_tbl_name || that_present_tbl_name) { + if (!(this_present_tbl_name && that_present_tbl_name)) + return false; + if (!this.tbl_name.equals(that.tbl_name)) + return false; + } + + boolean this_present_part_name = true && this.isSetPart_name(); + boolean that_present_part_name = true && that.isSetPart_name(); + if (this_present_part_name || that_present_part_name) { + if (!(this_present_part_name && that_present_part_name)) + return false; + if (!this.part_name.equals(that.part_name)) + return false; + } + + boolean this_present_deleteData = true; + boolean that_present_deleteData = true; + if (this_present_deleteData || that_present_deleteData) { + if (!(this_present_deleteData && that_present_deleteData)) + return false; + if (this.deleteData != that.deleteData) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_db_name = true && (isSetDb_name()); + builder.append(present_db_name); + if (present_db_name) + builder.append(db_name); + + boolean present_tbl_name = true && (isSetTbl_name()); + builder.append(present_tbl_name); + if (present_tbl_name) + builder.append(tbl_name); + + boolean present_part_name = true && (isSetPart_name()); + builder.append(present_part_name); + if (present_part_name) + builder.append(part_name); + + boolean present_deleteData = true; + builder.append(present_deleteData); + if (present_deleteData) + builder.append(deleteData); + + return builder.toHashCode(); + } + + public int compareTo(drop_partition_by_name_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + drop_partition_by_name_args typedOther = (drop_partition_by_name_args)other; + + lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDb_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.db_name, typedOther.db_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTbl_name()).compareTo(typedOther.isSetTbl_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTbl_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tbl_name, typedOther.tbl_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPart_name()).compareTo(typedOther.isSetPart_name()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPart_name()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.part_name, typedOther.part_name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDeleteData()).compareTo(typedOther.isSetDeleteData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDeleteData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.deleteData, typedOther.deleteData); + 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("drop_partition_by_name_args("); + boolean first = true; + + sb.append("db_name:"); + if (this.db_name == null) { + sb.append("null"); + } else { + sb.append(this.db_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("tbl_name:"); + if (this.tbl_name == null) { + sb.append("null"); + } else { + sb.append(this.tbl_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("part_name:"); + if (this.part_name == null) { + sb.append("null"); + } else { + sb.append(this.part_name); + } + first = false; + if (!first) sb.append(", "); + sb.append("deleteData:"); + sb.append(this.deleteData); + 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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + 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 drop_partition_by_name_argsStandardSchemeFactory implements SchemeFactory { + public drop_partition_by_name_argsStandardScheme getScheme() { + return new drop_partition_by_name_argsStandardScheme(); + } + } + + private static class drop_partition_by_name_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_name_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: // DB_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TBL_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tbl_name = iprot.readString(); + struct.setTbl_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PART_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.part_name = iprot.readString(); + struct.setPart_nameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DELETE_DATA + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.deleteData = iprot.readBool(); + struct.setDeleteDataIsSet(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, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.db_name != null) { + oprot.writeFieldBegin(DB_NAME_FIELD_DESC); + oprot.writeString(struct.db_name); + oprot.writeFieldEnd(); + } + if (struct.tbl_name != null) { + oprot.writeFieldBegin(TBL_NAME_FIELD_DESC); + oprot.writeString(struct.tbl_name); + oprot.writeFieldEnd(); + } + if (struct.part_name != null) { + oprot.writeFieldBegin(PART_NAME_FIELD_DESC); + oprot.writeString(struct.part_name); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(DELETE_DATA_FIELD_DESC); + oprot.writeBool(struct.deleteData); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class drop_partition_by_name_argsTupleSchemeFactory implements SchemeFactory { + public drop_partition_by_name_argsTupleScheme getScheme() { + return new drop_partition_by_name_argsTupleScheme(); + } + } + + private static class drop_partition_by_name_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDb_name()) { + optionals.set(0); + } + if (struct.isSetTbl_name()) { + optionals.set(1); + } + if (struct.isSetPart_name()) { + optionals.set(2); + } + if (struct.isSetDeleteData()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetDb_name()) { + oprot.writeString(struct.db_name); + } + if (struct.isSetTbl_name()) { + oprot.writeString(struct.tbl_name); + } + if (struct.isSetPart_name()) { + oprot.writeString(struct.part_name); + } + if (struct.isSetDeleteData()) { + oprot.writeBool(struct.deleteData); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.db_name = iprot.readString(); + struct.setDb_nameIsSet(true); + } + if (incoming.get(1)) { + struct.tbl_name = iprot.readString(); + struct.setTbl_nameIsSet(true); + } + if (incoming.get(2)) { + struct.part_name = iprot.readString(); + struct.setPart_nameIsSet(true); + } + if (incoming.get(3)) { + struct.deleteData = iprot.readBool(); + struct.setDeleteDataIsSet(true); + } + } + } + + } + + public static class drop_partition_by_name_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (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 Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_partition_by_name_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_by_name_resultTupleSchemeFactory()); + } + + private boolean success; // required + private NoSuchObjectException o1; // required + private MetaException o2; // 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"); + + 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; + 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 + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_result.class, metaDataMap); + } + + public drop_partition_by_name_result() { + } + + public drop_partition_by_name_result( + boolean success, + NoSuchObjectException o1, + MetaException o2) + { + this(); + this.success = success; + setSuccessIsSet(true); + this.o1 = o1; + this.o2 = o2; + } + + /** + * Performs a deep copy on other. + */ + public drop_partition_by_name_result(drop_partition_by_name_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new MetaException(other.o2); + } + } + + public drop_partition_by_name_result deepCopy() { + return new drop_partition_by_name_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + this.o1 = null; + this.o2 = null; + } + + public boolean isSuccess() { + return this.success; + } + + public void setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + } + + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public NoSuchObjectException getO1() { + return this.o1; + } + + public void setO1(NoSuchObjectException 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 MetaException getO2() { + return this.o2; + } + + public void setO2(MetaException 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 void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((MetaException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return Boolean.valueOf(isSuccess()); + + case O1: + return getO1(); + + case O2: + return getO2(); + + } + 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(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_partition_by_name_result) + return this.equals((drop_partition_by_name_result)that); + return false; + } + + public boolean equals(drop_partition_by_name_result that) { + if (that == null) + return false; + + boolean this_present_success = true; + boolean that_present_success = true; + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (this.success != 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; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_success = true; + builder.append(present_success); + if (present_success) + builder.append(success); + + boolean present_o1 = true && (isSetO1()); + builder.append(present_o1); + if (present_o1) + builder.append(o1); + + boolean present_o2 = true && (isSetO2()); + builder.append(present_o2); + if (present_o2) + builder.append(o2); + + return builder.toHashCode(); + } + + public int compareTo(drop_partition_by_name_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + drop_partition_by_name_result typedOther = (drop_partition_by_name_result)other; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(typedOther.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, typedOther.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(typedOther.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, typedOther.o2); + 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("drop_partition_by_name_result("); + boolean first = true; + + sb.append("success:"); + 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 + } + + 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 { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + 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 drop_partition_by_name_resultStandardSchemeFactory implements SchemeFactory { + public drop_partition_by_name_resultStandardScheme getScheme() { + return new drop_partition_by_name_resultStandardScheme(); + } + } + + private static class drop_partition_by_name_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, drop_partition_by_name_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.BOOL) { + struct.success = iprot.readBool(); + 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 NoSuchObjectException(); + 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 MetaException(); + 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, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + 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 drop_partition_by_name_resultTupleSchemeFactory implements SchemeFactory { + public drop_partition_by_name_resultTupleScheme getScheme() { + return new drop_partition_by_name_resultTupleScheme(); + } + } + + private static class drop_partition_by_name_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_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()) { + oprot.writeBool(struct.success); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, drop_partition_by_name_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new MetaException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + } + } + + } + + public static class drop_partition_by_name_with_environment_context_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("drop_partition_by_name_with_environment_context_args"); + + private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("db_name", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tbl_name", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PART_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("part_name", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField DELETE_DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("deleteData", org.apache.thrift.protocol.TType.BOOL, (short)4); + private static final org.apache.thrift.protocol.TField ENVIRONMENT_CONTEXT_FIELD_DESC = new org.apache.thrift.protocol.TField("environment_context", org.apache.thrift.protocol.TType.STRUCT, (short)5); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new drop_partition_by_name_with_environment_context_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new drop_partition_by_name_with_environment_context_argsTupleSchemeFactory()); + } + + private String db_name; // required + private String tbl_name; // required + private String part_name; // required + private boolean deleteData; // required + private EnvironmentContext environment_context; // 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 { + DB_NAME((short)1, "db_name"), + TBL_NAME((short)2, "tbl_name"), + PART_NAME((short)3, "part_name"), + DELETE_DATA((short)4, "deleteData"), + ENVIRONMENT_CONTEXT((short)5, "environment_context"); + + 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: // DB_NAME + return DB_NAME; + case 2: // TBL_NAME + return TBL_NAME; + case 3: // PART_NAME + return PART_NAME; + case 4: // DELETE_DATA + return DELETE_DATA; + case 5: // ENVIRONMENT_CONTEXT + return ENVIRONMENT_CONTEXT; + 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 + private static final int __DELETEDATA_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("db_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tbl_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PART_NAME, new org.apache.thrift.meta_data.FieldMetaData("part_name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DELETE_DATA, new org.apache.thrift.meta_data.FieldMetaData("deleteData", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.ENVIRONMENT_CONTEXT, new org.apache.thrift.meta_data.FieldMetaData("environment_context", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, EnvironmentContext.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(drop_partition_by_name_with_environment_context_args.class, metaDataMap); + } + + public drop_partition_by_name_with_environment_context_args() { + } + + public drop_partition_by_name_with_environment_context_args( + String db_name, + String tbl_name, + String part_name, + boolean deleteData, + EnvironmentContext environment_context) + { + this(); + this.db_name = db_name; + this.tbl_name = tbl_name; + this.part_name = part_name; + this.deleteData = deleteData; + setDeleteDataIsSet(true); + this.environment_context = environment_context; + } + + /** + * Performs a deep copy on other. + */ + public drop_partition_by_name_with_environment_context_args(drop_partition_by_name_with_environment_context_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDb_name()) { + this.db_name = other.db_name; + } + if (other.isSetTbl_name()) { + this.tbl_name = other.tbl_name; + } + if (other.isSetPart_name()) { + this.part_name = other.part_name; + } + this.deleteData = other.deleteData; + if (other.isSetEnvironment_context()) { + this.environment_context = new EnvironmentContext(other.environment_context); + } + } + + public drop_partition_by_name_with_environment_context_args deepCopy() { + return new drop_partition_by_name_with_environment_context_args(this); + } + + @Override + public void clear() { + this.db_name = null; + this.tbl_name = null; + this.part_name = null; + setDeleteDataIsSet(false); + this.deleteData = false; + this.environment_context = null; + } + + public String getDb_name() { + return this.db_name; + } + + public void setDb_name(String db_name) { + this.db_name = db_name; + } + + public void unsetDb_name() { + this.db_name = null; + } + + /** Returns true if field db_name is set (has been assigned a value) and false otherwise */ + public boolean isSetDb_name() { + return this.db_name != null; + } + + public void setDb_nameIsSet(boolean value) { + if (!value) { + this.db_name = null; + } + } + + public String getTbl_name() { + return this.tbl_name; + } + + public void setTbl_name(String tbl_name) { + this.tbl_name = tbl_name; + } + + public void unsetTbl_name() { + this.tbl_name = null; + } + + /** Returns true if field tbl_name is set (has been assigned a value) and false otherwise */ + public boolean isSetTbl_name() { + return this.tbl_name != null; + } + + public void setTbl_nameIsSet(boolean value) { + if (!value) { + this.tbl_name = null; + } + } + + public String getPart_name() { + return this.part_name; + } + + public void setPart_name(String part_name) { + this.part_name = part_name; + } + + public void unsetPart_name() { + this.part_name = null; + } + + /** Returns true if field part_name is set (has been assigned a value) and false otherwise */ + public boolean isSetPart_name() { + return this.part_name != null; + } + + public void setPart_nameIsSet(boolean value) { + if (!value) { + this.part_name = null; + } + } + + public boolean isDeleteData() { + return this.deleteData; + } + + public void setDeleteData(boolean deleteData) { + this.deleteData = deleteData; + setDeleteDataIsSet(true); + } + + public void unsetDeleteData() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DELETEDATA_ISSET_ID); + } + + /** Returns true if field deleteData is set (has been assigned a value) and false otherwise */ + public boolean isSetDeleteData() { + return EncodingUtils.testBit(__isset_bitfield, __DELETEDATA_ISSET_ID); + } + + public void setDeleteDataIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DELETEDATA_ISSET_ID, value); + } + + public EnvironmentContext getEnvironment_context() { + return this.environment_context; + } + + public void setEnvironment_context(EnvironmentContext environment_context) { + this.environment_context = environment_context; + } + + public void unsetEnvironment_context() { + this.environment_context = null; + } + + /** Returns true if field environment_context is set (has been assigned a value) and false otherwise */ + public boolean isSetEnvironment_context() { + return this.environment_context != null; + } + + public void setEnvironment_contextIsSet(boolean value) { + if (!value) { + this.environment_context = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DB_NAME: + if (value == null) { + unsetDb_name(); + } else { + setDb_name((String)value); + } + break; + + case TBL_NAME: + if (value == null) { + unsetTbl_name(); + } else { + setTbl_name((String)value); + } + break; + + case PART_NAME: + if (value == null) { + unsetPart_name(); + } else { + setPart_name((String)value); + } + break; + + case DELETE_DATA: + if (value == null) { + unsetDeleteData(); + } else { + setDeleteData((Boolean)value); + } + break; + + case ENVIRONMENT_CONTEXT: + if (value == null) { + unsetEnvironment_context(); + } else { + setEnvironment_context((EnvironmentContext)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DB_NAME: + return getDb_name(); + + case TBL_NAME: + return getTbl_name(); + + case PART_NAME: + return getPart_name(); + + case DELETE_DATA: + return Boolean.valueOf(isDeleteData()); + + case ENVIRONMENT_CONTEXT: + return getEnvironment_context(); + + } + 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 DB_NAME: + return isSetDb_name(); + case TBL_NAME: + return isSetTbl_name(); + case PART_NAME: + return isSetPart_name(); + case DELETE_DATA: + return isSetDeleteData(); + case ENVIRONMENT_CONTEXT: + return isSetEnvironment_context(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof drop_partition_by_name_with_environment_context_args) + return this.equals((drop_partition_by_name_with_environment_context_args)that); + return false; + } + + public boolean equals(drop_partition_by_name_with_environment_context_args that) { + if (that == null) + return false; + + boolean this_present_db_name = true && this.isSetDb_name(); + boolean that_present_db_name = true && that.isSetDb_name(); + if (this_present_db_name || that_present_db_name) { + if (!(this_present_db_name && that_present_db_name)) + return false; + if (!this.db_name.equals(that.db_name)) + return false; + } + + boolean this_present_tbl_name = true && this.isSetTbl_name(); + boolean that_present_tbl_name = true && that.isSetTbl_name(); + if (this_present_tbl_name || that_present_tbl_name) { + if (!(this_present_tbl_name && that_present_tbl_name)) + return false; + if (!this.tbl_name.equals(that.tbl_name)) + return false; + } + + boolean this_present_part_name = true && this.isSetPart_name(); + boolean that_present_part_name = true && that.isSetPart_name(); + if (this_present_part_name || that_present_part_name) { + if (!(this_present_part_name && that_present_part_name)) + return false; + if (!this.part_name.equals(that.part_name)) + return false; + } + + boolean this_present_deleteData = true; + boolean that_present_deleteData = true; + if (this_present_deleteData || that_present_deleteData) { + if (!(this_present_deleteData && that_present_deleteData)) + return false; + if (this.deleteData != that.deleteData) + return false; + } + + boolean this_present_environment_context = true && this.isSetEnvironment_context(); + boolean that_present_environment_context = true && that.isSetEnvironment_context(); + if (this_present_environment_context || that_present_environment_context) { + if (!(this_present_environment_context && that_present_environment_context)) + return false; + if (!this.environment_context.equals(that.environment_context)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_db_name = true && (isSetDb_name()); + builder.append(present_db_name); + if (present_db_name) + builder.append(db_name); + + boolean present_tbl_name = true && (isSetTbl_name()); + builder.append(present_tbl_name); + if (present_tbl_name) + builder.append(tbl_name); + + boolean present_part_name = true && (isSetPart_name()); + builder.append(present_part_name); + if (present_part_name) + builder.append(part_name); + + boolean present_deleteData = true; + builder.append(present_deleteData); + if (present_deleteData) + builder.append(deleteData); + + boolean present_environment_context = true && (isSetEnvironment_context()); + builder.append(present_environment_context); + if (present_environment_context) + builder.append(environment_context); + + return builder.toHashCode(); + } + + public int compareTo(drop_partition_by_name_with_environment_context_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + drop_partition_by_name_with_environment_context_args typedOther = (drop_partition_by_name_with_environment_context_args)other; lastComparison = Boolean.valueOf(isSetDb_name()).compareTo(typedOther.isSetDb_name()); if (lastComparison != 0) { @@ -50498,13 +53522,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, get_partition_args case 3: // PART_VALS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list564 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list564.size); - for (int _i565 = 0; _i565 < _list564.size; ++_i565) + org.apache.thrift.protocol.TList _list604 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list604.size); + for (int _i605 = 0; _i605 < _list604.size; ++_i605) { - String _elem566; // required - _elem566 = iprot.readString(); - struct.part_vals.add(_elem566); + String _elem606; // required + _elem606 = iprot.readString(); + struct.part_vals.add(_elem606); } iprot.readListEnd(); } @@ -50540,9 +53564,9 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, get_partition_args 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 _iter567 : struct.part_vals) + for (String _iter607 : struct.part_vals) { - oprot.writeString(_iter567); + oprot.writeString(_iter607); } oprot.writeListEnd(); } @@ -50585,9 +53609,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_args if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (String _iter568 : struct.part_vals) + for (String _iter608 : struct.part_vals) { - oprot.writeString(_iter568); + oprot.writeString(_iter608); } } } @@ -50607,13 +53631,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_args s } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list569 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list569.size); - for (int _i570 = 0; _i570 < _list569.size; ++_i570) + org.apache.thrift.protocol.TList _list609 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list609.size); + for (int _i610 = 0; _i610 < _list609.size; ++_i610) { - String _elem571; // required - _elem571 = iprot.readString(); - struct.part_vals.add(_elem571); + String _elem611; // required + _elem611 = iprot.readString(); + struct.part_vals.add(_elem611); } } struct.setPart_valsIsSet(true); @@ -51842,15 +54866,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 _map572 = iprot.readMapBegin(); - struct.partitionSpecs = new HashMap(2*_map572.size); - for (int _i573 = 0; _i573 < _map572.size; ++_i573) + org.apache.thrift.protocol.TMap _map612 = iprot.readMapBegin(); + struct.partitionSpecs = new HashMap(2*_map612.size); + for (int _i613 = 0; _i613 < _map612.size; ++_i613) { - String _key574; // required - String _val575; // required - _key574 = iprot.readString(); - _val575 = iprot.readString(); - struct.partitionSpecs.put(_key574, _val575); + String _key614; // required + String _val615; // required + _key614 = iprot.readString(); + _val615 = iprot.readString(); + struct.partitionSpecs.put(_key614, _val615); } iprot.readMapEnd(); } @@ -51908,10 +54932,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 _iter576 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter616 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter576.getKey()); - oprot.writeString(_iter576.getValue()); + oprot.writeString(_iter616.getKey()); + oprot.writeString(_iter616.getValue()); } oprot.writeMapEnd(); } @@ -51974,10 +54998,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, exchange_partition_ if (struct.isSetPartitionSpecs()) { { oprot.writeI32(struct.partitionSpecs.size()); - for (Map.Entry _iter577 : struct.partitionSpecs.entrySet()) + for (Map.Entry _iter617 : struct.partitionSpecs.entrySet()) { - oprot.writeString(_iter577.getKey()); - oprot.writeString(_iter577.getValue()); + oprot.writeString(_iter617.getKey()); + oprot.writeString(_iter617.getValue()); } } } @@ -52001,15 +55025,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, exchange_partition_a BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { { - org.apache.thrift.protocol.TMap _map578 = 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*_map578.size); - for (int _i579 = 0; _i579 < _map578.size; ++_i579) + org.apache.thrift.protocol.TMap _map618 = 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*_map618.size); + for (int _i619 = 0; _i619 < _map618.size; ++_i619) { - String _key580; // required - String _val581; // required - _key580 = iprot.readString(); - _val581 = iprot.readString(); - struct.partitionSpecs.put(_key580, _val581); + String _key620; // required + String _val621; // required + _key620 = iprot.readString(); + _val621 = iprot.readString(); + struct.partitionSpecs.put(_key620, _val621); } } struct.setPartitionSpecsIsSet(true); @@ -53497,13 +56521,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 _list582 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list582.size); - for (int _i583 = 0; _i583 < _list582.size; ++_i583) + org.apache.thrift.protocol.TList _list622 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list622.size); + for (int _i623 = 0; _i623 < _list622.size; ++_i623) { - String _elem584; // required - _elem584 = iprot.readString(); - struct.part_vals.add(_elem584); + String _elem624; // required + _elem624 = iprot.readString(); + struct.part_vals.add(_elem624); } iprot.readListEnd(); } @@ -53523,13 +56547,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 _list585 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list585.size); - for (int _i586 = 0; _i586 < _list585.size; ++_i586) + org.apache.thrift.protocol.TList _list625 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list625.size); + for (int _i626 = 0; _i626 < _list625.size; ++_i626) { - String _elem587; // required - _elem587 = iprot.readString(); - struct.group_names.add(_elem587); + String _elem627; // required + _elem627 = iprot.readString(); + struct.group_names.add(_elem627); } iprot.readListEnd(); } @@ -53565,9 +56589,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 _iter588 : struct.part_vals) + for (String _iter628 : struct.part_vals) { - oprot.writeString(_iter588); + oprot.writeString(_iter628); } oprot.writeListEnd(); } @@ -53582,9 +56606,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 _iter589 : struct.group_names) + for (String _iter629 : struct.group_names) { - oprot.writeString(_iter589); + oprot.writeString(_iter629); } oprot.writeListEnd(); } @@ -53633,9 +56657,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 _iter590 : struct.part_vals) + for (String _iter630 : struct.part_vals) { - oprot.writeString(_iter590); + oprot.writeString(_iter630); } } } @@ -53645,9 +56669,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 _iter591 : struct.group_names) + for (String _iter631 : struct.group_names) { - oprot.writeString(_iter591); + oprot.writeString(_iter631); } } } @@ -53667,13 +56691,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list592 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list592.size); - for (int _i593 = 0; _i593 < _list592.size; ++_i593) + org.apache.thrift.protocol.TList _list632 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list632.size); + for (int _i633 = 0; _i633 < _list632.size; ++_i633) { - String _elem594; // required - _elem594 = iprot.readString(); - struct.part_vals.add(_elem594); + String _elem634; // required + _elem634 = iprot.readString(); + struct.part_vals.add(_elem634); } } struct.setPart_valsIsSet(true); @@ -53684,13 +56708,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_with_a } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list595 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list595.size); - for (int _i596 = 0; _i596 < _list595.size; ++_i596) + org.apache.thrift.protocol.TList _list635 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list635.size); + for (int _i636 = 0; _i636 < _list635.size; ++_i636) { - String _elem597; // required - _elem597 = iprot.readString(); - struct.group_names.add(_elem597); + String _elem637; // required + _elem637 = iprot.readString(); + struct.group_names.add(_elem637); } } struct.setGroup_namesIsSet(true); @@ -56459,14 +59483,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 _list598 = iprot.readListBegin(); - struct.success = new ArrayList(_list598.size); - for (int _i599 = 0; _i599 < _list598.size; ++_i599) + org.apache.thrift.protocol.TList _list638 = iprot.readListBegin(); + struct.success = new ArrayList(_list638.size); + for (int _i639 = 0; _i639 < _list638.size; ++_i639) { - Partition _elem600; // required - _elem600 = new Partition(); - _elem600.read(iprot); - struct.success.add(_elem600); + Partition _elem640; // required + _elem640 = new Partition(); + _elem640.read(iprot); + struct.success.add(_elem640); } iprot.readListEnd(); } @@ -56510,9 +59534,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 _iter601 : struct.success) + for (Partition _iter641 : struct.success) { - _iter601.write(oprot); + _iter641.write(oprot); } oprot.writeListEnd(); } @@ -56559,9 +59583,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter602 : struct.success) + for (Partition _iter642 : struct.success) { - _iter602.write(oprot); + _iter642.write(oprot); } } } @@ -56579,14 +59603,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 _list603 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list603.size); - for (int _i604 = 0; _i604 < _list603.size; ++_i604) + org.apache.thrift.protocol.TList _list643 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list643.size); + for (int _i644 = 0; _i644 < _list643.size; ++_i644) { - Partition _elem605; // required - _elem605 = new Partition(); - _elem605.read(iprot); - struct.success.add(_elem605); + Partition _elem645; // required + _elem645 = new Partition(); + _elem645.read(iprot); + struct.success.add(_elem645); } } struct.setSuccessIsSet(true); @@ -57279,13 +60303,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 _list606 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list606.size); - for (int _i607 = 0; _i607 < _list606.size; ++_i607) + org.apache.thrift.protocol.TList _list646 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list646.size); + for (int _i647 = 0; _i647 < _list646.size; ++_i647) { - String _elem608; // required - _elem608 = iprot.readString(); - struct.group_names.add(_elem608); + String _elem648; // required + _elem648 = iprot.readString(); + struct.group_names.add(_elem648); } iprot.readListEnd(); } @@ -57329,9 +60353,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 _iter609 : struct.group_names) + for (String _iter649 : struct.group_names) { - oprot.writeString(_iter609); + oprot.writeString(_iter649); } oprot.writeListEnd(); } @@ -57386,9 +60410,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 _iter610 : struct.group_names) + for (String _iter650 : struct.group_names) { - oprot.writeString(_iter610); + oprot.writeString(_iter650); } } } @@ -57416,13 +60440,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_with_ } if (incoming.get(4)) { { - org.apache.thrift.protocol.TList _list611 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list611.size); - for (int _i612 = 0; _i612 < _list611.size; ++_i612) + org.apache.thrift.protocol.TList _list651 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list651.size); + for (int _i652 = 0; _i652 < _list651.size; ++_i652) { - String _elem613; // required - _elem613 = iprot.readString(); - struct.group_names.add(_elem613); + String _elem653; // required + _elem653 = iprot.readString(); + struct.group_names.add(_elem653); } } struct.setGroup_namesIsSet(true); @@ -57909,14 +60933,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 _list614 = iprot.readListBegin(); - struct.success = new ArrayList(_list614.size); - for (int _i615 = 0; _i615 < _list614.size; ++_i615) + org.apache.thrift.protocol.TList _list654 = iprot.readListBegin(); + struct.success = new ArrayList(_list654.size); + for (int _i655 = 0; _i655 < _list654.size; ++_i655) { - Partition _elem616; // required - _elem616 = new Partition(); - _elem616.read(iprot); - struct.success.add(_elem616); + Partition _elem656; // required + _elem656 = new Partition(); + _elem656.read(iprot); + struct.success.add(_elem656); } iprot.readListEnd(); } @@ -57960,9 +60984,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 _iter617 : struct.success) + for (Partition _iter657 : struct.success) { - _iter617.write(oprot); + _iter657.write(oprot); } oprot.writeListEnd(); } @@ -58009,9 +61033,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_with if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter618 : struct.success) + for (Partition _iter658 : struct.success) { - _iter618.write(oprot); + _iter658.write(oprot); } } } @@ -58029,14 +61053,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 _list619 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list619.size); - for (int _i620 = 0; _i620 < _list619.size; ++_i620) + org.apache.thrift.protocol.TList _list659 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list659.size); + for (int _i660 = 0; _i660 < _list659.size; ++_i660) { - Partition _elem621; // required - _elem621 = new Partition(); - _elem621.read(iprot); - struct.success.add(_elem621); + Partition _elem661; // required + _elem661 = new Partition(); + _elem661.read(iprot); + struct.success.add(_elem661); } } struct.setSuccessIsSet(true); @@ -59018,13 +62042,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 _list622 = iprot.readListBegin(); - struct.success = new ArrayList(_list622.size); - for (int _i623 = 0; _i623 < _list622.size; ++_i623) + org.apache.thrift.protocol.TList _list662 = iprot.readListBegin(); + struct.success = new ArrayList(_list662.size); + for (int _i663 = 0; _i663 < _list662.size; ++_i663) { - String _elem624; // required - _elem624 = iprot.readString(); - struct.success.add(_elem624); + String _elem664; // required + _elem664 = iprot.readString(); + struct.success.add(_elem664); } iprot.readListEnd(); } @@ -59059,9 +62083,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 _iter625 : struct.success) + for (String _iter665 : struct.success) { - oprot.writeString(_iter625); + oprot.writeString(_iter665); } oprot.writeListEnd(); } @@ -59100,9 +62124,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter626 : struct.success) + for (String _iter666 : struct.success) { - oprot.writeString(_iter626); + oprot.writeString(_iter666); } } } @@ -59117,13 +62141,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 _list627 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list627.size); - for (int _i628 = 0; _i628 < _list627.size; ++_i628) + org.apache.thrift.protocol.TList _list667 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list667.size); + for (int _i668 = 0; _i668 < _list667.size; ++_i668) { - String _elem629; // required - _elem629 = iprot.readString(); - struct.success.add(_elem629); + String _elem669; // required + _elem669 = iprot.readString(); + struct.success.add(_elem669); } } struct.setSuccessIsSet(true); @@ -59714,13 +62738,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 _list630 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list630.size); - for (int _i631 = 0; _i631 < _list630.size; ++_i631) + org.apache.thrift.protocol.TList _list670 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list670.size); + for (int _i671 = 0; _i671 < _list670.size; ++_i671) { - String _elem632; // required - _elem632 = iprot.readString(); - struct.part_vals.add(_elem632); + String _elem672; // required + _elem672 = iprot.readString(); + struct.part_vals.add(_elem672); } iprot.readListEnd(); } @@ -59764,9 +62788,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 _iter633 : struct.part_vals) + for (String _iter673 : struct.part_vals) { - oprot.writeString(_iter633); + oprot.writeString(_iter673); } oprot.writeListEnd(); } @@ -59815,9 +62839,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 _iter634 : struct.part_vals) + for (String _iter674 : struct.part_vals) { - oprot.writeString(_iter634); + oprot.writeString(_iter674); } } } @@ -59840,13 +62864,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_ar } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list635 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list635.size); - for (int _i636 = 0; _i636 < _list635.size; ++_i636) + org.apache.thrift.protocol.TList _list675 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list675.size); + for (int _i676 = 0; _i676 < _list675.size; ++_i676) { - String _elem637; // required - _elem637 = iprot.readString(); - struct.part_vals.add(_elem637); + String _elem677; // required + _elem677 = iprot.readString(); + struct.part_vals.add(_elem677); } } struct.setPart_valsIsSet(true); @@ -60337,14 +63361,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 _list638 = iprot.readListBegin(); - struct.success = new ArrayList(_list638.size); - for (int _i639 = 0; _i639 < _list638.size; ++_i639) + org.apache.thrift.protocol.TList _list678 = iprot.readListBegin(); + struct.success = new ArrayList(_list678.size); + for (int _i679 = 0; _i679 < _list678.size; ++_i679) { - Partition _elem640; // required - _elem640 = new Partition(); - _elem640.read(iprot); - struct.success.add(_elem640); + Partition _elem680; // required + _elem680 = new Partition(); + _elem680.read(iprot); + struct.success.add(_elem680); } iprot.readListEnd(); } @@ -60388,9 +63412,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 _iter641 : struct.success) + for (Partition _iter681 : struct.success) { - _iter641.write(oprot); + _iter681.write(oprot); } oprot.writeListEnd(); } @@ -60437,9 +63461,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_r if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter642 : struct.success) + for (Partition _iter682 : struct.success) { - _iter642.write(oprot); + _iter682.write(oprot); } } } @@ -60457,14 +63481,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 _list643 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list643.size); - for (int _i644 = 0; _i644 < _list643.size; ++_i644) + org.apache.thrift.protocol.TList _list683 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list683.size); + for (int _i684 = 0; _i684 < _list683.size; ++_i684) { - Partition _elem645; // required - _elem645 = new Partition(); - _elem645.read(iprot); - struct.success.add(_elem645); + Partition _elem685; // required + _elem685 = new Partition(); + _elem685.read(iprot); + struct.success.add(_elem685); } } struct.setSuccessIsSet(true); @@ -61242,13 +64266,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 _list646 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list646.size); - for (int _i647 = 0; _i647 < _list646.size; ++_i647) + org.apache.thrift.protocol.TList _list686 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list686.size); + for (int _i687 = 0; _i687 < _list686.size; ++_i687) { - String _elem648; // required - _elem648 = iprot.readString(); - struct.part_vals.add(_elem648); + String _elem688; // required + _elem688 = iprot.readString(); + struct.part_vals.add(_elem688); } iprot.readListEnd(); } @@ -61276,13 +64300,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 _list649 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list649.size); - for (int _i650 = 0; _i650 < _list649.size; ++_i650) + org.apache.thrift.protocol.TList _list689 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list689.size); + for (int _i690 = 0; _i690 < _list689.size; ++_i690) { - String _elem651; // required - _elem651 = iprot.readString(); - struct.group_names.add(_elem651); + String _elem691; // required + _elem691 = iprot.readString(); + struct.group_names.add(_elem691); } iprot.readListEnd(); } @@ -61318,9 +64342,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 _iter652 : struct.part_vals) + for (String _iter692 : struct.part_vals) { - oprot.writeString(_iter652); + oprot.writeString(_iter692); } oprot.writeListEnd(); } @@ -61338,9 +64362,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 _iter653 : struct.group_names) + for (String _iter693 : struct.group_names) { - oprot.writeString(_iter653); + oprot.writeString(_iter693); } oprot.writeListEnd(); } @@ -61392,9 +64416,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 _iter654 : struct.part_vals) + for (String _iter694 : struct.part_vals) { - oprot.writeString(_iter654); + oprot.writeString(_iter694); } } } @@ -61407,9 +64431,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 _iter655 : struct.group_names) + for (String _iter695 : struct.group_names) { - oprot.writeString(_iter655); + oprot.writeString(_iter695); } } } @@ -61429,13 +64453,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list656 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list656.size); - for (int _i657 = 0; _i657 < _list656.size; ++_i657) + org.apache.thrift.protocol.TList _list696 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list696.size); + for (int _i697 = 0; _i697 < _list696.size; ++_i697) { - String _elem658; // required - _elem658 = iprot.readString(); - struct.part_vals.add(_elem658); + String _elem698; // required + _elem698 = iprot.readString(); + struct.part_vals.add(_elem698); } } struct.setPart_valsIsSet(true); @@ -61450,13 +64474,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_wi } if (incoming.get(5)) { { - org.apache.thrift.protocol.TList _list659 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list659.size); - for (int _i660 = 0; _i660 < _list659.size; ++_i660) + org.apache.thrift.protocol.TList _list699 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list699.size); + for (int _i700 = 0; _i700 < _list699.size; ++_i700) { - String _elem661; // required - _elem661 = iprot.readString(); - struct.group_names.add(_elem661); + String _elem701; // required + _elem701 = iprot.readString(); + struct.group_names.add(_elem701); } } struct.setGroup_namesIsSet(true); @@ -61943,14 +64967,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 _list662 = iprot.readListBegin(); - struct.success = new ArrayList(_list662.size); - for (int _i663 = 0; _i663 < _list662.size; ++_i663) + org.apache.thrift.protocol.TList _list702 = iprot.readListBegin(); + struct.success = new ArrayList(_list702.size); + for (int _i703 = 0; _i703 < _list702.size; ++_i703) { - Partition _elem664; // required - _elem664 = new Partition(); - _elem664.read(iprot); - struct.success.add(_elem664); + Partition _elem704; // required + _elem704 = new Partition(); + _elem704.read(iprot); + struct.success.add(_elem704); } iprot.readListEnd(); } @@ -61994,9 +65018,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 _iter665 : struct.success) + for (Partition _iter705 : struct.success) { - _iter665.write(oprot); + _iter705.write(oprot); } oprot.writeListEnd(); } @@ -62043,9 +65067,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_ps_w if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter666 : struct.success) + for (Partition _iter706 : struct.success) { - _iter666.write(oprot); + _iter706.write(oprot); } } } @@ -62063,14 +65087,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 _list667 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list667.size); - for (int _i668 = 0; _i668 < _list667.size; ++_i668) + org.apache.thrift.protocol.TList _list707 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list707.size); + for (int _i708 = 0; _i708 < _list707.size; ++_i708) { - Partition _elem669; // required - _elem669 = new Partition(); - _elem669.read(iprot); - struct.success.add(_elem669); + Partition _elem709; // required + _elem709 = new Partition(); + _elem709.read(iprot); + struct.success.add(_elem709); } } struct.setSuccessIsSet(true); @@ -62666,13 +65690,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 _list670 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list670.size); - for (int _i671 = 0; _i671 < _list670.size; ++_i671) + org.apache.thrift.protocol.TList _list710 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list710.size); + for (int _i711 = 0; _i711 < _list710.size; ++_i711) { - String _elem672; // required - _elem672 = iprot.readString(); - struct.part_vals.add(_elem672); + String _elem712; // required + _elem712 = iprot.readString(); + struct.part_vals.add(_elem712); } iprot.readListEnd(); } @@ -62716,9 +65740,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 _iter673 : struct.part_vals) + for (String _iter713 : struct.part_vals) { - oprot.writeString(_iter673); + oprot.writeString(_iter713); } oprot.writeListEnd(); } @@ -62767,9 +65791,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 _iter674 : struct.part_vals) + for (String _iter714 : struct.part_vals) { - oprot.writeString(_iter674); + oprot.writeString(_iter714); } } } @@ -62792,13 +65816,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partition_names_ } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list675 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list675.size); - for (int _i676 = 0; _i676 < _list675.size; ++_i676) + org.apache.thrift.protocol.TList _list715 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list715.size); + for (int _i716 = 0; _i716 < _list715.size; ++_i716) { - String _elem677; // required - _elem677 = iprot.readString(); - struct.part_vals.add(_elem677); + String _elem717; // required + _elem717 = iprot.readString(); + struct.part_vals.add(_elem717); } } struct.setPart_valsIsSet(true); @@ -63289,13 +66313,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 _list678 = iprot.readListBegin(); - struct.success = new ArrayList(_list678.size); - for (int _i679 = 0; _i679 < _list678.size; ++_i679) + org.apache.thrift.protocol.TList _list718 = iprot.readListBegin(); + struct.success = new ArrayList(_list718.size); + for (int _i719 = 0; _i719 < _list718.size; ++_i719) { - String _elem680; // required - _elem680 = iprot.readString(); - struct.success.add(_elem680); + String _elem720; // required + _elem720 = iprot.readString(); + struct.success.add(_elem720); } iprot.readListEnd(); } @@ -63339,9 +66363,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 _iter681 : struct.success) + for (String _iter721 : struct.success) { - oprot.writeString(_iter681); + oprot.writeString(_iter721); } oprot.writeListEnd(); } @@ -63388,9 +66412,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partition_names if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter682 : struct.success) + for (String _iter722 : struct.success) { - oprot.writeString(_iter682); + oprot.writeString(_iter722); } } } @@ -63408,13 +66432,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 _list683 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list683.size); - for (int _i684 = 0; _i684 < _list683.size; ++_i684) + org.apache.thrift.protocol.TList _list723 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list723.size); + for (int _i724 = 0; _i724 < _list723.size; ++_i724) { - String _elem685; // required - _elem685 = iprot.readString(); - struct.success.add(_elem685); + String _elem725; // required + _elem725 = iprot.readString(); + struct.success.add(_elem725); } } struct.setSuccessIsSet(true); @@ -64581,14 +67605,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 _list686 = iprot.readListBegin(); - struct.success = new ArrayList(_list686.size); - for (int _i687 = 0; _i687 < _list686.size; ++_i687) + org.apache.thrift.protocol.TList _list726 = iprot.readListBegin(); + struct.success = new ArrayList(_list726.size); + for (int _i727 = 0; _i727 < _list726.size; ++_i727) { - Partition _elem688; // required - _elem688 = new Partition(); - _elem688.read(iprot); - struct.success.add(_elem688); + Partition _elem728; // required + _elem728 = new Partition(); + _elem728.read(iprot); + struct.success.add(_elem728); } iprot.readListEnd(); } @@ -64632,9 +67656,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 _iter689 : struct.success) + for (Partition _iter729 : struct.success) { - _iter689.write(oprot); + _iter729.write(oprot); } oprot.writeListEnd(); } @@ -64681,9 +67705,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_f if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter690 : struct.success) + for (Partition _iter730 : struct.success) { - _iter690.write(oprot); + _iter730.write(oprot); } } } @@ -64701,14 +67725,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 _list691 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list691.size); - for (int _i692 = 0; _i692 < _list691.size; ++_i692) + org.apache.thrift.protocol.TList _list731 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list731.size); + for (int _i732 = 0; _i732 < _list731.size; ++_i732) { - Partition _elem693; // required - _elem693 = new Partition(); - _elem693.read(iprot); - struct.success.add(_elem693); + Partition _elem733; // required + _elem733 = new Partition(); + _elem733.read(iprot); + struct.success.add(_elem733); } } struct.setSuccessIsSet(true); @@ -66159,13 +69183,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 _list694 = iprot.readListBegin(); - struct.names = new ArrayList(_list694.size); - for (int _i695 = 0; _i695 < _list694.size; ++_i695) + org.apache.thrift.protocol.TList _list734 = iprot.readListBegin(); + struct.names = new ArrayList(_list734.size); + for (int _i735 = 0; _i735 < _list734.size; ++_i735) { - String _elem696; // required - _elem696 = iprot.readString(); - struct.names.add(_elem696); + String _elem736; // required + _elem736 = iprot.readString(); + struct.names.add(_elem736); } iprot.readListEnd(); } @@ -66201,9 +69225,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 _iter697 : struct.names) + for (String _iter737 : struct.names) { - oprot.writeString(_iter697); + oprot.writeString(_iter737); } oprot.writeListEnd(); } @@ -66246,9 +69270,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetNames()) { { oprot.writeI32(struct.names.size()); - for (String _iter698 : struct.names) + for (String _iter738 : struct.names) { - oprot.writeString(_iter698); + oprot.writeString(_iter738); } } } @@ -66268,13 +69292,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_na } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list699 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.names = new ArrayList(_list699.size); - for (int _i700 = 0; _i700 < _list699.size; ++_i700) + org.apache.thrift.protocol.TList _list739 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.names = new ArrayList(_list739.size); + for (int _i740 = 0; _i740 < _list739.size; ++_i740) { - String _elem701; // required - _elem701 = iprot.readString(); - struct.names.add(_elem701); + String _elem741; // required + _elem741 = iprot.readString(); + struct.names.add(_elem741); } } struct.setNamesIsSet(true); @@ -66761,14 +69785,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 _list702 = iprot.readListBegin(); - struct.success = new ArrayList(_list702.size); - for (int _i703 = 0; _i703 < _list702.size; ++_i703) + org.apache.thrift.protocol.TList _list742 = iprot.readListBegin(); + struct.success = new ArrayList(_list742.size); + for (int _i743 = 0; _i743 < _list742.size; ++_i743) { - Partition _elem704; // required - _elem704 = new Partition(); - _elem704.read(iprot); - struct.success.add(_elem704); + Partition _elem744; // required + _elem744 = new Partition(); + _elem744.read(iprot); + struct.success.add(_elem744); } iprot.readListEnd(); } @@ -66812,9 +69836,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 _iter705 : struct.success) + for (Partition _iter745 : struct.success) { - _iter705.write(oprot); + _iter745.write(oprot); } oprot.writeListEnd(); } @@ -66861,9 +69885,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_partitions_by_n if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Partition _iter706 : struct.success) + for (Partition _iter746 : struct.success) { - _iter706.write(oprot); + _iter746.write(oprot); } } } @@ -66881,14 +69905,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 _list707 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list707.size); - for (int _i708 = 0; _i708 < _list707.size; ++_i708) + org.apache.thrift.protocol.TList _list747 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list747.size); + for (int _i748 = 0; _i748 < _list747.size; ++_i748) { - Partition _elem709; // required - _elem709 = new Partition(); - _elem709.read(iprot); - struct.success.add(_elem709); + Partition _elem749; // required + _elem749 = new Partition(); + _elem749.read(iprot); + struct.success.add(_elem749); } } struct.setSuccessIsSet(true); @@ -68438,14 +71462,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 _list710 = iprot.readListBegin(); - struct.new_parts = new ArrayList(_list710.size); - for (int _i711 = 0; _i711 < _list710.size; ++_i711) + org.apache.thrift.protocol.TList _list750 = iprot.readListBegin(); + struct.new_parts = new ArrayList(_list750.size); + for (int _i751 = 0; _i751 < _list750.size; ++_i751) { - Partition _elem712; // required - _elem712 = new Partition(); - _elem712.read(iprot); - struct.new_parts.add(_elem712); + Partition _elem752; // required + _elem752 = new Partition(); + _elem752.read(iprot); + struct.new_parts.add(_elem752); } iprot.readListEnd(); } @@ -68481,9 +71505,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 _iter713 : struct.new_parts) + for (Partition _iter753 : struct.new_parts) { - _iter713.write(oprot); + _iter753.write(oprot); } oprot.writeListEnd(); } @@ -68526,9 +71550,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 _iter714 : struct.new_parts) + for (Partition _iter754 : struct.new_parts) { - _iter714.write(oprot); + _iter754.write(oprot); } } } @@ -68548,14 +71572,14 @@ public void read(org.apache.thrift.protocol.TProtocol prot, alter_partitions_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list715 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.new_parts = new ArrayList(_list715.size); - for (int _i716 = 0; _i716 < _list715.size; ++_i716) + org.apache.thrift.protocol.TList _list755 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.new_parts = new ArrayList(_list755.size); + for (int _i756 = 0; _i756 < _list755.size; ++_i756) { - Partition _elem717; // required - _elem717 = new Partition(); - _elem717.read(iprot); - struct.new_parts.add(_elem717); + Partition _elem757; // required + _elem757 = new Partition(); + _elem757.read(iprot); + struct.new_parts.add(_elem757); } } struct.setNew_partsIsSet(true); @@ -70754,13 +73778,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 _list718 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list718.size); - for (int _i719 = 0; _i719 < _list718.size; ++_i719) + org.apache.thrift.protocol.TList _list758 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list758.size); + for (int _i759 = 0; _i759 < _list758.size; ++_i759) { - String _elem720; // required - _elem720 = iprot.readString(); - struct.part_vals.add(_elem720); + String _elem760; // required + _elem760 = iprot.readString(); + struct.part_vals.add(_elem760); } iprot.readListEnd(); } @@ -70805,9 +73829,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 _iter721 : struct.part_vals) + for (String _iter761 : struct.part_vals) { - oprot.writeString(_iter721); + oprot.writeString(_iter761); } oprot.writeListEnd(); } @@ -70858,9 +73882,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 _iter722 : struct.part_vals) + for (String _iter762 : struct.part_vals) { - oprot.writeString(_iter722); + oprot.writeString(_iter762); } } } @@ -70883,13 +73907,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, rename_partition_arg } if (incoming.get(2)) { { - org.apache.thrift.protocol.TList _list723 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list723.size); - for (int _i724 = 0; _i724 < _list723.size; ++_i724) + org.apache.thrift.protocol.TList _list763 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list763.size); + for (int _i764 = 0; _i764 < _list763.size; ++_i764) { - String _elem725; // required - _elem725 = iprot.readString(); - struct.part_vals.add(_elem725); + String _elem765; // required + _elem765 = iprot.readString(); + struct.part_vals.add(_elem765); } } struct.setPart_valsIsSet(true); @@ -71766,13 +74790,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 _list726 = iprot.readListBegin(); - struct.part_vals = new ArrayList(_list726.size); - for (int _i727 = 0; _i727 < _list726.size; ++_i727) + org.apache.thrift.protocol.TList _list766 = iprot.readListBegin(); + struct.part_vals = new ArrayList(_list766.size); + for (int _i767 = 0; _i767 < _list766.size; ++_i767) { - String _elem728; // required - _elem728 = iprot.readString(); - struct.part_vals.add(_elem728); + String _elem768; // required + _elem768 = iprot.readString(); + struct.part_vals.add(_elem768); } iprot.readListEnd(); } @@ -71806,9 +74830,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 _iter729 : struct.part_vals) + for (String _iter769 : struct.part_vals) { - oprot.writeString(_iter729); + oprot.writeString(_iter769); } oprot.writeListEnd(); } @@ -71845,9 +74869,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 _iter730 : struct.part_vals) + for (String _iter770 : struct.part_vals) { - oprot.writeString(_iter730); + oprot.writeString(_iter770); } } } @@ -71862,13 +74886,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 _list731 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.part_vals = new ArrayList(_list731.size); - for (int _i732 = 0; _i732 < _list731.size; ++_i732) + org.apache.thrift.protocol.TList _list771 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.part_vals = new ArrayList(_list771.size); + for (int _i772 = 0; _i772 < _list771.size; ++_i772) { - String _elem733; // required - _elem733 = iprot.readString(); - struct.part_vals.add(_elem733); + String _elem773; // required + _elem773 = iprot.readString(); + struct.part_vals.add(_elem773); } } struct.setPart_valsIsSet(true); @@ -74026,13 +77050,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 _list734 = iprot.readListBegin(); - struct.success = new ArrayList(_list734.size); - for (int _i735 = 0; _i735 < _list734.size; ++_i735) + org.apache.thrift.protocol.TList _list774 = iprot.readListBegin(); + struct.success = new ArrayList(_list774.size); + for (int _i775 = 0; _i775 < _list774.size; ++_i775) { - String _elem736; // required - _elem736 = iprot.readString(); - struct.success.add(_elem736); + String _elem776; // required + _elem776 = iprot.readString(); + struct.success.add(_elem776); } iprot.readListEnd(); } @@ -74067,9 +77091,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 _iter737 : struct.success) + for (String _iter777 : struct.success) { - oprot.writeString(_iter737); + oprot.writeString(_iter777); } oprot.writeListEnd(); } @@ -74108,9 +77132,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, partition_name_to_v if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter738 : struct.success) + for (String _iter778 : struct.success) { - oprot.writeString(_iter738); + oprot.writeString(_iter778); } } } @@ -74125,13 +77149,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 _list739 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list739.size); - for (int _i740 = 0; _i740 < _list739.size; ++_i740) + org.apache.thrift.protocol.TList _list779 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list779.size); + for (int _i780 = 0; _i780 < _list779.size; ++_i780) { - String _elem741; // required - _elem741 = iprot.readString(); - struct.success.add(_elem741); + String _elem781; // required + _elem781 = iprot.readString(); + struct.success.add(_elem781); } } struct.setSuccessIsSet(true); @@ -74905,15 +77929,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 _map742 = iprot.readMapBegin(); - struct.success = new HashMap(2*_map742.size); - for (int _i743 = 0; _i743 < _map742.size; ++_i743) + org.apache.thrift.protocol.TMap _map782 = iprot.readMapBegin(); + struct.success = new HashMap(2*_map782.size); + for (int _i783 = 0; _i783 < _map782.size; ++_i783) { - String _key744; // required - String _val745; // required - _key744 = iprot.readString(); - _val745 = iprot.readString(); - struct.success.put(_key744, _val745); + String _key784; // required + String _val785; // required + _key784 = iprot.readString(); + _val785 = iprot.readString(); + struct.success.put(_key784, _val785); } iprot.readMapEnd(); } @@ -74948,10 +77972,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 _iter746 : struct.success.entrySet()) + for (Map.Entry _iter786 : struct.success.entrySet()) { - oprot.writeString(_iter746.getKey()); - oprot.writeString(_iter746.getValue()); + oprot.writeString(_iter786.getKey()); + oprot.writeString(_iter786.getValue()); } oprot.writeMapEnd(); } @@ -74990,10 +78014,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 _iter747 : struct.success.entrySet()) + for (Map.Entry _iter787 : struct.success.entrySet()) { - oprot.writeString(_iter747.getKey()); - oprot.writeString(_iter747.getValue()); + oprot.writeString(_iter787.getKey()); + oprot.writeString(_iter787.getValue()); } } } @@ -75008,15 +78032,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 _map748 = 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*_map748.size); - for (int _i749 = 0; _i749 < _map748.size; ++_i749) + org.apache.thrift.protocol.TMap _map788 = 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*_map788.size); + for (int _i789 = 0; _i789 < _map788.size; ++_i789) { - String _key750; // required - String _val751; // required - _key750 = iprot.readString(); - _val751 = iprot.readString(); - struct.success.put(_key750, _val751); + String _key790; // required + String _val791; // required + _key790 = iprot.readString(); + _val791 = iprot.readString(); + struct.success.put(_key790, _val791); } } struct.setSuccessIsSet(true); @@ -75622,15 +78646,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 _map752 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map752.size); - for (int _i753 = 0; _i753 < _map752.size; ++_i753) + org.apache.thrift.protocol.TMap _map792 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map792.size); + for (int _i793 = 0; _i793 < _map792.size; ++_i793) { - String _key754; // required - String _val755; // required - _key754 = iprot.readString(); - _val755 = iprot.readString(); - struct.part_vals.put(_key754, _val755); + String _key794; // required + String _val795; // required + _key794 = iprot.readString(); + _val795 = iprot.readString(); + struct.part_vals.put(_key794, _val795); } iprot.readMapEnd(); } @@ -75674,10 +78698,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 _iter756 : struct.part_vals.entrySet()) + for (Map.Entry _iter796 : struct.part_vals.entrySet()) { - oprot.writeString(_iter756.getKey()); - oprot.writeString(_iter756.getValue()); + oprot.writeString(_iter796.getKey()); + oprot.writeString(_iter796.getValue()); } oprot.writeMapEnd(); } @@ -75728,10 +78752,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, markPartitionForEve if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter757 : struct.part_vals.entrySet()) + for (Map.Entry _iter797 : struct.part_vals.entrySet()) { - oprot.writeString(_iter757.getKey()); - oprot.writeString(_iter757.getValue()); + oprot.writeString(_iter797.getKey()); + oprot.writeString(_iter797.getValue()); } } } @@ -75754,15 +78778,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, markPartitionForEven } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map758 = 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*_map758.size); - for (int _i759 = 0; _i759 < _map758.size; ++_i759) + org.apache.thrift.protocol.TMap _map798 = 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*_map798.size); + for (int _i799 = 0; _i799 < _map798.size; ++_i799) { - String _key760; // required - String _val761; // required - _key760 = iprot.readString(); - _val761 = iprot.readString(); - struct.part_vals.put(_key760, _val761); + String _key800; // required + String _val801; // required + _key800 = iprot.readString(); + _val801 = iprot.readString(); + struct.part_vals.put(_key800, _val801); } } struct.setPart_valsIsSet(true); @@ -77257,15 +80281,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 _map762 = iprot.readMapBegin(); - struct.part_vals = new HashMap(2*_map762.size); - for (int _i763 = 0; _i763 < _map762.size; ++_i763) + org.apache.thrift.protocol.TMap _map802 = iprot.readMapBegin(); + struct.part_vals = new HashMap(2*_map802.size); + for (int _i803 = 0; _i803 < _map802.size; ++_i803) { - String _key764; // required - String _val765; // required - _key764 = iprot.readString(); - _val765 = iprot.readString(); - struct.part_vals.put(_key764, _val765); + String _key804; // required + String _val805; // required + _key804 = iprot.readString(); + _val805 = iprot.readString(); + struct.part_vals.put(_key804, _val805); } iprot.readMapEnd(); } @@ -77309,10 +80333,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 _iter766 : struct.part_vals.entrySet()) + for (Map.Entry _iter806 : struct.part_vals.entrySet()) { - oprot.writeString(_iter766.getKey()); - oprot.writeString(_iter766.getValue()); + oprot.writeString(_iter806.getKey()); + oprot.writeString(_iter806.getValue()); } oprot.writeMapEnd(); } @@ -77363,10 +80387,10 @@ public void write(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFo if (struct.isSetPart_vals()) { { oprot.writeI32(struct.part_vals.size()); - for (Map.Entry _iter767 : struct.part_vals.entrySet()) + for (Map.Entry _iter807 : struct.part_vals.entrySet()) { - oprot.writeString(_iter767.getKey()); - oprot.writeString(_iter767.getValue()); + oprot.writeString(_iter807.getKey()); + oprot.writeString(_iter807.getValue()); } } } @@ -77389,15 +80413,15 @@ public void read(org.apache.thrift.protocol.TProtocol prot, isPartitionMarkedFor } if (incoming.get(2)) { { - org.apache.thrift.protocol.TMap _map768 = 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*_map768.size); - for (int _i769 = 0; _i769 < _map768.size; ++_i769) + org.apache.thrift.protocol.TMap _map808 = 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*_map808.size); + for (int _i809 = 0; _i809 < _map808.size; ++_i809) { - String _key770; // required - String _val771; // required - _key770 = iprot.readString(); - _val771 = iprot.readString(); - struct.part_vals.put(_key770, _val771); + String _key810; // required + String _val811; // required + _key810 = iprot.readString(); + _val811 = iprot.readString(); + struct.part_vals.put(_key810, _val811); } } struct.setPart_valsIsSet(true); @@ -84121,14 +87145,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 _list772 = iprot.readListBegin(); - struct.success = new ArrayList(_list772.size); - for (int _i773 = 0; _i773 < _list772.size; ++_i773) + org.apache.thrift.protocol.TList _list812 = iprot.readListBegin(); + struct.success = new ArrayList(_list812.size); + for (int _i813 = 0; _i813 < _list812.size; ++_i813) { - Index _elem774; // required - _elem774 = new Index(); - _elem774.read(iprot); - struct.success.add(_elem774); + Index _elem814; // required + _elem814 = new Index(); + _elem814.read(iprot); + struct.success.add(_elem814); } iprot.readListEnd(); } @@ -84172,9 +87196,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 _iter775 : struct.success) + for (Index _iter815 : struct.success) { - _iter775.write(oprot); + _iter815.write(oprot); } oprot.writeListEnd(); } @@ -84221,9 +87245,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_indexes_result if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Index _iter776 : struct.success) + for (Index _iter816 : struct.success) { - _iter776.write(oprot); + _iter816.write(oprot); } } } @@ -84241,14 +87265,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 _list777 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list777.size); - for (int _i778 = 0; _i778 < _list777.size; ++_i778) + org.apache.thrift.protocol.TList _list817 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list817.size); + for (int _i818 = 0; _i818 < _list817.size; ++_i818) { - Index _elem779; // required - _elem779 = new Index(); - _elem779.read(iprot); - struct.success.add(_elem779); + Index _elem819; // required + _elem819 = new Index(); + _elem819.read(iprot); + struct.success.add(_elem819); } } struct.setSuccessIsSet(true); @@ -85230,13 +88254,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 _list780 = iprot.readListBegin(); - struct.success = new ArrayList(_list780.size); - for (int _i781 = 0; _i781 < _list780.size; ++_i781) + org.apache.thrift.protocol.TList _list820 = iprot.readListBegin(); + struct.success = new ArrayList(_list820.size); + for (int _i821 = 0; _i821 < _list820.size; ++_i821) { - String _elem782; // required - _elem782 = iprot.readString(); - struct.success.add(_elem782); + String _elem822; // required + _elem822 = iprot.readString(); + struct.success.add(_elem822); } iprot.readListEnd(); } @@ -85271,9 +88295,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 _iter783 : struct.success) + for (String _iter823 : struct.success) { - oprot.writeString(_iter783); + oprot.writeString(_iter823); } oprot.writeListEnd(); } @@ -85312,9 +88336,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_index_names_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter784 : struct.success) + for (String _iter824 : struct.success) { - oprot.writeString(_iter784); + oprot.writeString(_iter824); } } } @@ -85329,13 +88353,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 _list785 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list785.size); - for (int _i786 = 0; _i786 < _list785.size; ++_i786) + org.apache.thrift.protocol.TList _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list825.size); + for (int _i826 = 0; _i826 < _list825.size; ++_i826) { - String _elem787; // required - _elem787 = iprot.readString(); - struct.success.add(_elem787); + String _elem827; // required + _elem827 = iprot.readString(); + struct.success.add(_elem827); } } struct.setSuccessIsSet(true); @@ -98990,13 +102014,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 _list788 = iprot.readListBegin(); - struct.success = new ArrayList(_list788.size); - for (int _i789 = 0; _i789 < _list788.size; ++_i789) + org.apache.thrift.protocol.TList _list828 = iprot.readListBegin(); + struct.success = new ArrayList(_list828.size); + for (int _i829 = 0; _i829 < _list828.size; ++_i829) { - String _elem790; // required - _elem790 = iprot.readString(); - struct.success.add(_elem790); + String _elem830; // required + _elem830 = iprot.readString(); + struct.success.add(_elem830); } iprot.readListEnd(); } @@ -99031,9 +102055,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 _iter791 : struct.success) + for (String _iter831 : struct.success) { - oprot.writeString(_iter791); + oprot.writeString(_iter831); } oprot.writeListEnd(); } @@ -99072,9 +102096,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_functions_resul if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter792 : struct.success) + for (String _iter832 : struct.success) { - oprot.writeString(_iter792); + oprot.writeString(_iter832); } } } @@ -99089,13 +102113,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 _list793 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list793.size); - for (int _i794 = 0; _i794 < _list793.size; ++_i794) + org.apache.thrift.protocol.TList _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list833.size); + for (int _i834 = 0; _i834 < _list833.size; ++_i834) { - String _elem795; // required - _elem795 = iprot.readString(); - struct.success.add(_elem795); + String _elem835; // required + _elem835 = iprot.readString(); + struct.success.add(_elem835); } } struct.setSuccessIsSet(true); @@ -102438,13 +105462,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 _list796 = iprot.readListBegin(); - struct.success = new ArrayList(_list796.size); - for (int _i797 = 0; _i797 < _list796.size; ++_i797) + org.apache.thrift.protocol.TList _list836 = iprot.readListBegin(); + struct.success = new ArrayList(_list836.size); + for (int _i837 = 0; _i837 < _list836.size; ++_i837) { - String _elem798; // required - _elem798 = iprot.readString(); - struct.success.add(_elem798); + String _elem838; // required + _elem838 = iprot.readString(); + struct.success.add(_elem838); } iprot.readListEnd(); } @@ -102479,9 +105503,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 _iter799 : struct.success) + for (String _iter839 : struct.success) { - oprot.writeString(_iter799); + oprot.writeString(_iter839); } oprot.writeListEnd(); } @@ -102520,9 +105544,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, get_role_names_resu if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter800 : struct.success) + for (String _iter840 : struct.success) { - oprot.writeString(_iter800); + oprot.writeString(_iter840); } } } @@ -102537,13 +105561,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 _list801 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list801.size); - for (int _i802 = 0; _i802 < _list801.size; ++_i802) + org.apache.thrift.protocol.TList _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list841.size); + for (int _i842 = 0; _i842 < _list841.size; ++_i842) { - String _elem803; // required - _elem803 = iprot.readString(); - struct.success.add(_elem803); + String _elem843; // required + _elem843 = iprot.readString(); + struct.success.add(_elem843); } } struct.setSuccessIsSet(true); @@ -105834,14 +108858,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 _list804 = iprot.readListBegin(); - struct.success = new ArrayList(_list804.size); - for (int _i805 = 0; _i805 < _list804.size; ++_i805) + org.apache.thrift.protocol.TList _list844 = iprot.readListBegin(); + struct.success = new ArrayList(_list844.size); + for (int _i845 = 0; _i845 < _list844.size; ++_i845) { - Role _elem806; // required - _elem806 = new Role(); - _elem806.read(iprot); - struct.success.add(_elem806); + Role _elem846; // required + _elem846 = new Role(); + _elem846.read(iprot); + struct.success.add(_elem846); } iprot.readListEnd(); } @@ -105876,9 +108900,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 _iter807 : struct.success) + for (Role _iter847 : struct.success) { - _iter807.write(oprot); + _iter847.write(oprot); } oprot.writeListEnd(); } @@ -105917,9 +108941,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_roles_result s if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (Role _iter808 : struct.success) + for (Role _iter848 : struct.success) { - _iter808.write(oprot); + _iter848.write(oprot); } } } @@ -105934,14 +108958,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 _list809 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list809.size); - for (int _i810 = 0; _i810 < _list809.size; ++_i810) + 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); + for (int _i850 = 0; _i850 < _list849.size; ++_i850) { - Role _elem811; // required - _elem811 = new Role(); - _elem811.read(iprot); - struct.success.add(_elem811); + Role _elem851; // required + _elem851 = new Role(); + _elem851.read(iprot); + struct.success.add(_elem851); } } struct.setSuccessIsSet(true); @@ -108117,13 +111141,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 _list812 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list812.size); - for (int _i813 = 0; _i813 < _list812.size; ++_i813) + org.apache.thrift.protocol.TList _list852 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list852.size); + for (int _i853 = 0; _i853 < _list852.size; ++_i853) { - String _elem814; // required - _elem814 = iprot.readString(); - struct.group_names.add(_elem814); + String _elem854; // required + _elem854 = iprot.readString(); + struct.group_names.add(_elem854); } iprot.readListEnd(); } @@ -108159,9 +111183,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 _iter815 : struct.group_names) + for (String _iter855 : struct.group_names) { - oprot.writeString(_iter815); + oprot.writeString(_iter855); } oprot.writeListEnd(); } @@ -108204,9 +111228,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 _iter816 : struct.group_names) + for (String _iter856 : struct.group_names) { - oprot.writeString(_iter816); + oprot.writeString(_iter856); } } } @@ -108227,13 +111251,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, get_privilege_set_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.group_names = new ArrayList(_list817.size); - for (int _i818 = 0; _i818 < _list817.size; ++_i818) + org.apache.thrift.protocol.TList _list857 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list857.size); + for (int _i858 = 0; _i858 < _list857.size; ++_i858) { - String _elem819; // required - _elem819 = iprot.readString(); - struct.group_names.add(_elem819); + String _elem859; // required + _elem859 = iprot.readString(); + struct.group_names.add(_elem859); } } struct.setGroup_namesIsSet(true); @@ -109691,14 +112715,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 _list820 = iprot.readListBegin(); - struct.success = new ArrayList(_list820.size); - for (int _i821 = 0; _i821 < _list820.size; ++_i821) + org.apache.thrift.protocol.TList _list860 = iprot.readListBegin(); + struct.success = new ArrayList(_list860.size); + for (int _i861 = 0; _i861 < _list860.size; ++_i861) { - HiveObjectPrivilege _elem822; // required - _elem822 = new HiveObjectPrivilege(); - _elem822.read(iprot); - struct.success.add(_elem822); + HiveObjectPrivilege _elem862; // required + _elem862 = new HiveObjectPrivilege(); + _elem862.read(iprot); + struct.success.add(_elem862); } iprot.readListEnd(); } @@ -109733,9 +112757,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 _iter823 : struct.success) + for (HiveObjectPrivilege _iter863 : struct.success) { - _iter823.write(oprot); + _iter863.write(oprot); } oprot.writeListEnd(); } @@ -109774,9 +112798,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, list_privileges_res if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (HiveObjectPrivilege _iter824 : struct.success) + for (HiveObjectPrivilege _iter864 : struct.success) { - _iter824.write(oprot); + _iter864.write(oprot); } } } @@ -109791,14 +112815,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 _list825 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList(_list825.size); - for (int _i826 = 0; _i826 < _list825.size; ++_i826) + org.apache.thrift.protocol.TList _list865 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList(_list865.size); + for (int _i866 = 0; _i866 < _list865.size; ++_i866) { - HiveObjectPrivilege _elem827; // required - _elem827 = new HiveObjectPrivilege(); - _elem827.read(iprot); - struct.success.add(_elem827); + HiveObjectPrivilege _elem867; // required + _elem867 = new HiveObjectPrivilege(); + _elem867.read(iprot); + struct.success.add(_elem867); } } struct.setSuccessIsSet(true); @@ -111871,13 +114895,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 _list828 = iprot.readListBegin(); - struct.group_names = new ArrayList(_list828.size); - for (int _i829 = 0; _i829 < _list828.size; ++_i829) + org.apache.thrift.protocol.TList _list868 = iprot.readListBegin(); + struct.group_names = new ArrayList(_list868.size); + for (int _i869 = 0; _i869 < _list868.size; ++_i869) { - String _elem830; // required - _elem830 = iprot.readString(); - struct.group_names.add(_elem830); + String _elem870; // required + _elem870 = iprot.readString(); + struct.group_names.add(_elem870); } iprot.readListEnd(); } @@ -111908,9 +114932,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 _iter831 : struct.group_names) + for (String _iter871 : struct.group_names) { - oprot.writeString(_iter831); + oprot.writeString(_iter871); } oprot.writeListEnd(); } @@ -111947,9 +114971,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 _iter832 : struct.group_names) + for (String _iter872 : struct.group_names) { - oprot.writeString(_iter832); + oprot.writeString(_iter872); } } } @@ -111965,13 +114989,13 @@ public void read(org.apache.thrift.protocol.TProtocol prot, set_ugi_args struct) } if (incoming.get(1)) { { - org.apache.thrift.protocol.TList _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.group_names = new ArrayList(_list833.size); - for (int _i834 = 0; _i834 < _list833.size; ++_i834) + org.apache.thrift.protocol.TList _list873 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.group_names = new ArrayList(_list873.size); + for (int _i874 = 0; _i874 < _list873.size; ++_i874) { - String _elem835; // required - _elem835 = iprot.readString(); - struct.group_names.add(_elem835); + String _elem875; // required + _elem875 = iprot.readString(); + struct.group_names.add(_elem875); } } struct.setGroup_namesIsSet(true); @@ -112377,13 +115401,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 _list836 = iprot.readListBegin(); - struct.success = new ArrayList(_list836.size); - for (int _i837 = 0; _i837 < _list836.size; ++_i837) + org.apache.thrift.protocol.TList _list876 = iprot.readListBegin(); + struct.success = new ArrayList(_list876.size); + for (int _i877 = 0; _i877 < _list876.size; ++_i877) { - String _elem838; // required - _elem838 = iprot.readString(); - struct.success.add(_elem838); + String _elem878; // required + _elem878 = iprot.readString(); + struct.success.add(_elem878); } iprot.readListEnd(); } @@ -112418,9 +115442,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 _iter839 : struct.success) + for (String _iter879 : struct.success) { - oprot.writeString(_iter839); + oprot.writeString(_iter879); } oprot.writeListEnd(); } @@ -112459,9 +115483,9 @@ public void write(org.apache.thrift.protocol.TProtocol prot, set_ugi_result stru if (struct.isSetSuccess()) { { oprot.writeI32(struct.success.size()); - for (String _iter840 : struct.success) + for (String _iter880 : struct.success) { - oprot.writeString(_iter840); + oprot.writeString(_iter880); } } } @@ -112476,13 +115500,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 _list841 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList(_list841.size); - for (int _i842 = 0; _i842 < _list841.size; ++_i842) + org.apache.thrift.protocol.TList _list881 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList(_list881.size); + for (int _i882 = 0; _i882 < _list881.size; ++_i882) { - String _elem843; // required - _elem843 = iprot.readString(); - struct.success.add(_elem843); + String _elem883; // required + _elem883 = iprot.readString(); + struct.success.add(_elem883); } } 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 c79624f..88ce9ce 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -47,6 +47,8 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { public function append_partition_with_environment_context($db_name, $tbl_name, $part_vals, \metastore\EnvironmentContext $environment_context); public function append_partition_by_name($db_name, $tbl_name, $part_name); public function append_partition_by_name_with_environment_context($db_name, $tbl_name, $part_name, \metastore\EnvironmentContext $environment_context); + public function add_drop_partitions($db_name, $tbl_name, $add_parts, $drop_part_vals, $deleteData); + public function drop_partitions($db_name, $tbl_name, $part_vals, $deleteData); public function drop_partition($db_name, $tbl_name, $part_vals, $deleteData); public function drop_partition_with_environment_context($db_name, $tbl_name, $part_vals, $deleteData, \metastore\EnvironmentContext $environment_context); public function drop_partition_by_name($db_name, $tbl_name, $part_name, $deleteData); @@ -1943,6 +1945,127 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("append_partition_by_name_with_environment_context failed: unknown result"); } + public function add_drop_partitions($db_name, $tbl_name, $add_parts, $drop_part_vals, $deleteData) + { + $this->send_add_drop_partitions($db_name, $tbl_name, $add_parts, $drop_part_vals, $deleteData); + return $this->recv_add_drop_partitions(); + } + + public function send_add_drop_partitions($db_name, $tbl_name, $add_parts, $drop_part_vals, $deleteData) + { + $args = new \metastore\ThriftHiveMetastore_add_drop_partitions_args(); + $args->db_name = $db_name; + $args->tbl_name = $tbl_name; + $args->add_parts = $add_parts; + $args->drop_part_vals = $drop_part_vals; + $args->deleteData = $deleteData; + $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'add_drop_partitions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('add_drop_partitions', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_add_drop_partitions() + { + $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_add_drop_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_add_drop_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("add_drop_partitions failed: unknown result"); + } + + public function drop_partitions($db_name, $tbl_name, $part_vals, $deleteData) + { + $this->send_drop_partitions($db_name, $tbl_name, $part_vals, $deleteData); + return $this->recv_drop_partitions(); + } + + public function send_drop_partitions($db_name, $tbl_name, $part_vals, $deleteData) + { + $args = new \metastore\ThriftHiveMetastore_drop_partitions_args(); + $args->db_name = $db_name; + $args->tbl_name = $tbl_name; + $args->part_vals = $part_vals; + $args->deleteData = $deleteData; + $bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'drop_partitions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('drop_partitions', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_drop_partitions() + { + $bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_drop_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_drop_partitions_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + throw new \Exception("drop_partitions failed: unknown result"); + } + public function drop_partition($db_name, $tbl_name, $part_vals, $deleteData) { $this->send_drop_partition($db_name, $tbl_name, $part_vals, $deleteData); @@ -13356,9 +13479,651 @@ class ThriftHiveMetastore_append_partition_by_name_with_environment_context_resu $xfer += $this->o2->write($output); $xfer += $output->writeFieldEnd(); } - if ($this->o3 !== null) { - $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); - $xfer += $this->o3->write($output); + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_add_drop_partitions_args { + static $_TSPEC; + + public $db_name = null; + public $tbl_name = null; + public $add_parts = null; + public $drop_part_vals = null; + public $deleteData = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'db_name', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'tbl_name', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'add_parts', + 'type' => TType::LST, + 'etype' => TType::STRUCT, + 'elem' => array( + 'type' => TType::STRUCT, + 'class' => '\metastore\Partition', + ), + ), + 4 => array( + 'var' => 'drop_part_vals', + 'type' => TType::LST, + 'etype' => TType::LST, + 'elem' => array( + 'type' => TType::LST, + 'etype' => TType::STRING, + 'elem' => array( + 'type' => TType::STRING, + ), + ), + ), + 5 => array( + 'var' => 'deleteData', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['db_name'])) { + $this->db_name = $vals['db_name']; + } + if (isset($vals['tbl_name'])) { + $this->tbl_name = $vals['tbl_name']; + } + if (isset($vals['add_parts'])) { + $this->add_parts = $vals['add_parts']; + } + if (isset($vals['drop_part_vals'])) { + $this->drop_part_vals = $vals['drop_part_vals']; + } + if (isset($vals['deleteData'])) { + $this->deleteData = $vals['deleteData']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_add_drop_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::STRING) { + $xfer += $input->readString($this->db_name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->tbl_name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::LST) { + $this->add_parts = array(); + $_size486 = 0; + $_etype489 = 0; + $xfer += $input->readListBegin($_etype489, $_size486); + for ($_i490 = 0; $_i490 < $_size486; ++$_i490) + { + $elem491 = null; + $elem491 = new \metastore\Partition(); + $xfer += $elem491->read($input); + $this->add_parts []= $elem491; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::LST) { + $this->drop_part_vals = array(); + $_size492 = 0; + $_etype495 = 0; + $xfer += $input->readListBegin($_etype495, $_size492); + for ($_i496 = 0; $_i496 < $_size492; ++$_i496) + { + $elem497 = null; + $elem497 = array(); + $_size498 = 0; + $_etype501 = 0; + $xfer += $input->readListBegin($_etype501, $_size498); + for ($_i502 = 0; $_i502 < $_size498; ++$_i502) + { + $elem503 = null; + $xfer += $input->readString($elem503); + $elem497 []= $elem503; + } + $xfer += $input->readListEnd(); + $this->drop_part_vals []= $elem497; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 5: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->deleteData); + } 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_add_drop_partitions_args'); + if ($this->db_name !== null) { + $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1); + $xfer += $output->writeString($this->db_name); + $xfer += $output->writeFieldEnd(); + } + if ($this->tbl_name !== null) { + $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2); + $xfer += $output->writeString($this->tbl_name); + $xfer += $output->writeFieldEnd(); + } + if ($this->add_parts !== null) { + if (!is_array($this->add_parts)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('add_parts', TType::LST, 3); + { + $output->writeListBegin(TType::STRUCT, count($this->add_parts)); + { + foreach ($this->add_parts as $iter504) + { + $xfer += $iter504->write($output); + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->drop_part_vals !== null) { + if (!is_array($this->drop_part_vals)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('drop_part_vals', TType::LST, 4); + { + $output->writeListBegin(TType::LST, count($this->drop_part_vals)); + { + foreach ($this->drop_part_vals as $iter505) + { + { + $output->writeListBegin(TType::STRING, count($iter505)); + { + foreach ($iter505 as $iter506) + { + $xfer += $output->writeString($iter506); + } + } + $output->writeListEnd(); + } + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->deleteData !== null) { + $xfer += $output->writeFieldBegin('deleteData', TType::BOOL, 5); + $xfer += $output->writeBool($this->deleteData); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_add_drop_partitions_result { + static $_TSPEC; + + public $success = null; + public $o1 = null; + public $o2 = null; + public $o3 = null; + public $o4 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::BOOL, + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\AlreadyExistsException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + ); + } + 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_add_drop_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::BOOL) { + $xfer += $input->readBool($this->success); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\InvalidObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\AlreadyExistsException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\NoSuchObjectException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\MetaException(); + $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_add_drop_partitions_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::BOOL, 0); + $xfer += $output->writeBool($this->success); + $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_drop_partitions_args { + static $_TSPEC; + + public $db_name = null; + public $tbl_name = null; + public $part_vals = null; + public $deleteData = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'db_name', + 'type' => TType::STRING, + ), + 2 => array( + 'var' => 'tbl_name', + 'type' => TType::STRING, + ), + 3 => array( + 'var' => 'part_vals', + 'type' => TType::LST, + 'etype' => TType::LST, + 'elem' => array( + 'type' => TType::LST, + 'etype' => TType::STRING, + 'elem' => array( + 'type' => TType::STRING, + ), + ), + ), + 4 => array( + 'var' => 'deleteData', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['db_name'])) { + $this->db_name = $vals['db_name']; + } + if (isset($vals['tbl_name'])) { + $this->tbl_name = $vals['tbl_name']; + } + if (isset($vals['part_vals'])) { + $this->part_vals = $vals['part_vals']; + } + if (isset($vals['deleteData'])) { + $this->deleteData = $vals['deleteData']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_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::STRING) { + $xfer += $input->readString($this->db_name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRING) { + $xfer += $input->readString($this->tbl_name); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::LST) { + $this->part_vals = array(); + $_size507 = 0; + $_etype510 = 0; + $xfer += $input->readListBegin($_etype510, $_size507); + for ($_i511 = 0; $_i511 < $_size507; ++$_i511) + { + $elem512 = null; + $elem512 = array(); + $_size513 = 0; + $_etype516 = 0; + $xfer += $input->readListBegin($_etype516, $_size513); + for ($_i517 = 0; $_i517 < $_size513; ++$_i517) + { + $elem518 = null; + $xfer += $input->readString($elem518); + $elem512 []= $elem518; + } + $xfer += $input->readListEnd(); + $this->part_vals []= $elem512; + } + $xfer += $input->readListEnd(); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->deleteData); + } 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_drop_partitions_args'); + if ($this->db_name !== null) { + $xfer += $output->writeFieldBegin('db_name', TType::STRING, 1); + $xfer += $output->writeString($this->db_name); + $xfer += $output->writeFieldEnd(); + } + if ($this->tbl_name !== null) { + $xfer += $output->writeFieldBegin('tbl_name', TType::STRING, 2); + $xfer += $output->writeString($this->tbl_name); + $xfer += $output->writeFieldEnd(); + } + if ($this->part_vals !== null) { + if (!is_array($this->part_vals)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('part_vals', TType::LST, 3); + { + $output->writeListBegin(TType::LST, count($this->part_vals)); + { + foreach ($this->part_vals as $iter519) + { + { + $output->writeListBegin(TType::STRING, count($iter519)); + { + foreach ($iter519 as $iter520) + { + $xfer += $output->writeString($iter520); + } + } + $output->writeListEnd(); + } + } + } + $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if ($this->deleteData !== null) { + $xfer += $output->writeFieldBegin('deleteData', TType::BOOL, 4); + $xfer += $output->writeBool($this->deleteData); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_drop_partitions_result { + static $_TSPEC; + + public $success = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::BOOL, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_drop_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::BOOL) { + $xfer += $input->readBool($this->success); + } 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_drop_partitions_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::BOOL, 0); + $xfer += $output->writeBool($this->success); $xfer += $output->writeFieldEnd(); } $xfer += $output->writeFieldStop(); @@ -13453,14 +14218,14 @@ class ThriftHiveMetastore_drop_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size486 = 0; - $_etype489 = 0; - $xfer += $input->readListBegin($_etype489, $_size486); - for ($_i490 = 0; $_i490 < $_size486; ++$_i490) + $_size521 = 0; + $_etype524 = 0; + $xfer += $input->readListBegin($_etype524, $_size521); + for ($_i525 = 0; $_i525 < $_size521; ++$_i525) { - $elem491 = null; - $xfer += $input->readString($elem491); - $this->part_vals []= $elem491; + $elem526 = null; + $xfer += $input->readString($elem526); + $this->part_vals []= $elem526; } $xfer += $input->readListEnd(); } else { @@ -13505,9 +14270,9 @@ class ThriftHiveMetastore_drop_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter492) + foreach ($this->part_vals as $iter527) { - $xfer += $output->writeString($iter492); + $xfer += $output->writeString($iter527); } } $output->writeListEnd(); @@ -13736,14 +14501,14 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size493 = 0; - $_etype496 = 0; - $xfer += $input->readListBegin($_etype496, $_size493); - for ($_i497 = 0; $_i497 < $_size493; ++$_i497) + $_size528 = 0; + $_etype531 = 0; + $xfer += $input->readListBegin($_etype531, $_size528); + for ($_i532 = 0; $_i532 < $_size528; ++$_i532) { - $elem498 = null; - $xfer += $input->readString($elem498); - $this->part_vals []= $elem498; + $elem533 = null; + $xfer += $input->readString($elem533); + $this->part_vals []= $elem533; } $xfer += $input->readListEnd(); } else { @@ -13796,9 +14561,9 @@ class ThriftHiveMetastore_drop_partition_with_environment_context_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter499) + foreach ($this->part_vals as $iter534) { - $xfer += $output->writeString($iter499); + $xfer += $output->writeString($iter534); } } $output->writeListEnd(); @@ -14737,14 +15502,14 @@ class ThriftHiveMetastore_get_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size500 = 0; - $_etype503 = 0; - $xfer += $input->readListBegin($_etype503, $_size500); - for ($_i504 = 0; $_i504 < $_size500; ++$_i504) + $_size535 = 0; + $_etype538 = 0; + $xfer += $input->readListBegin($_etype538, $_size535); + for ($_i539 = 0; $_i539 < $_size535; ++$_i539) { - $elem505 = null; - $xfer += $input->readString($elem505); - $this->part_vals []= $elem505; + $elem540 = null; + $xfer += $input->readString($elem540); + $this->part_vals []= $elem540; } $xfer += $input->readListEnd(); } else { @@ -14782,9 +15547,9 @@ class ThriftHiveMetastore_get_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter506) + foreach ($this->part_vals as $iter541) { - $xfer += $output->writeString($iter506); + $xfer += $output->writeString($iter541); } } $output->writeListEnd(); @@ -15002,17 +15767,17 @@ class ThriftHiveMetastore_exchange_partition_args { case 1: if ($ftype == TType::MAP) { $this->partitionSpecs = array(); - $_size507 = 0; - $_ktype508 = 0; - $_vtype509 = 0; - $xfer += $input->readMapBegin($_ktype508, $_vtype509, $_size507); - for ($_i511 = 0; $_i511 < $_size507; ++$_i511) + $_size542 = 0; + $_ktype543 = 0; + $_vtype544 = 0; + $xfer += $input->readMapBegin($_ktype543, $_vtype544, $_size542); + for ($_i546 = 0; $_i546 < $_size542; ++$_i546) { - $key512 = ''; - $val513 = ''; - $xfer += $input->readString($key512); - $xfer += $input->readString($val513); - $this->partitionSpecs[$key512] = $val513; + $key547 = ''; + $val548 = ''; + $xfer += $input->readString($key547); + $xfer += $input->readString($val548); + $this->partitionSpecs[$key547] = $val548; } $xfer += $input->readMapEnd(); } else { @@ -15068,10 +15833,10 @@ class ThriftHiveMetastore_exchange_partition_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->partitionSpecs)); { - foreach ($this->partitionSpecs as $kiter514 => $viter515) + foreach ($this->partitionSpecs as $kiter549 => $viter550) { - $xfer += $output->writeString($kiter514); - $xfer += $output->writeString($viter515); + $xfer += $output->writeString($kiter549); + $xfer += $output->writeString($viter550); } } $output->writeMapEnd(); @@ -15367,14 +16132,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size516 = 0; - $_etype519 = 0; - $xfer += $input->readListBegin($_etype519, $_size516); - for ($_i520 = 0; $_i520 < $_size516; ++$_i520) + $_size551 = 0; + $_etype554 = 0; + $xfer += $input->readListBegin($_etype554, $_size551); + for ($_i555 = 0; $_i555 < $_size551; ++$_i555) { - $elem521 = null; - $xfer += $input->readString($elem521); - $this->part_vals []= $elem521; + $elem556 = null; + $xfer += $input->readString($elem556); + $this->part_vals []= $elem556; } $xfer += $input->readListEnd(); } else { @@ -15391,14 +16156,14 @@ class ThriftHiveMetastore_get_partition_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size522 = 0; - $_etype525 = 0; - $xfer += $input->readListBegin($_etype525, $_size522); - for ($_i526 = 0; $_i526 < $_size522; ++$_i526) + $_size557 = 0; + $_etype560 = 0; + $xfer += $input->readListBegin($_etype560, $_size557); + for ($_i561 = 0; $_i561 < $_size557; ++$_i561) { - $elem527 = null; - $xfer += $input->readString($elem527); - $this->group_names []= $elem527; + $elem562 = null; + $xfer += $input->readString($elem562); + $this->group_names []= $elem562; } $xfer += $input->readListEnd(); } else { @@ -15436,9 +16201,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter528) + foreach ($this->part_vals as $iter563) { - $xfer += $output->writeString($iter528); + $xfer += $output->writeString($iter563); } } $output->writeListEnd(); @@ -15458,9 +16223,9 @@ class ThriftHiveMetastore_get_partition_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter529) + foreach ($this->group_names as $iter564) { - $xfer += $output->writeString($iter529); + $xfer += $output->writeString($iter564); } } $output->writeListEnd(); @@ -16006,15 +16771,15 @@ class ThriftHiveMetastore_get_partitions_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size530 = 0; - $_etype533 = 0; - $xfer += $input->readListBegin($_etype533, $_size530); - for ($_i534 = 0; $_i534 < $_size530; ++$_i534) + $_size565 = 0; + $_etype568 = 0; + $xfer += $input->readListBegin($_etype568, $_size565); + for ($_i569 = 0; $_i569 < $_size565; ++$_i569) { - $elem535 = null; - $elem535 = new \metastore\Partition(); - $xfer += $elem535->read($input); - $this->success []= $elem535; + $elem570 = null; + $elem570 = new \metastore\Partition(); + $xfer += $elem570->read($input); + $this->success []= $elem570; } $xfer += $input->readListEnd(); } else { @@ -16058,9 +16823,9 @@ class ThriftHiveMetastore_get_partitions_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter536) + foreach ($this->success as $iter571) { - $xfer += $iter536->write($output); + $xfer += $iter571->write($output); } } $output->writeListEnd(); @@ -16191,14 +16956,14 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { case 5: if ($ftype == TType::LST) { $this->group_names = array(); - $_size537 = 0; - $_etype540 = 0; - $xfer += $input->readListBegin($_etype540, $_size537); - for ($_i541 = 0; $_i541 < $_size537; ++$_i541) + $_size572 = 0; + $_etype575 = 0; + $xfer += $input->readListBegin($_etype575, $_size572); + for ($_i576 = 0; $_i576 < $_size572; ++$_i576) { - $elem542 = null; - $xfer += $input->readString($elem542); - $this->group_names []= $elem542; + $elem577 = null; + $xfer += $input->readString($elem577); + $this->group_names []= $elem577; } $xfer += $input->readListEnd(); } else { @@ -16246,9 +17011,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter543) + foreach ($this->group_names as $iter578) { - $xfer += $output->writeString($iter543); + $xfer += $output->writeString($iter578); } } $output->writeListEnd(); @@ -16328,15 +17093,15 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size544 = 0; - $_etype547 = 0; - $xfer += $input->readListBegin($_etype547, $_size544); - for ($_i548 = 0; $_i548 < $_size544; ++$_i548) + $_size579 = 0; + $_etype582 = 0; + $xfer += $input->readListBegin($_etype582, $_size579); + for ($_i583 = 0; $_i583 < $_size579; ++$_i583) { - $elem549 = null; - $elem549 = new \metastore\Partition(); - $xfer += $elem549->read($input); - $this->success []= $elem549; + $elem584 = null; + $elem584 = new \metastore\Partition(); + $xfer += $elem584->read($input); + $this->success []= $elem584; } $xfer += $input->readListEnd(); } else { @@ -16380,9 +17145,9 @@ class ThriftHiveMetastore_get_partitions_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter550) + foreach ($this->success as $iter585) { - $xfer += $iter550->write($output); + $xfer += $iter585->write($output); } } $output->writeListEnd(); @@ -16574,14 +17339,14 @@ class ThriftHiveMetastore_get_partition_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size551 = 0; - $_etype554 = 0; - $xfer += $input->readListBegin($_etype554, $_size551); - for ($_i555 = 0; $_i555 < $_size551; ++$_i555) + $_size586 = 0; + $_etype589 = 0; + $xfer += $input->readListBegin($_etype589, $_size586); + for ($_i590 = 0; $_i590 < $_size586; ++$_i590) { - $elem556 = null; - $xfer += $input->readString($elem556); - $this->success []= $elem556; + $elem591 = null; + $xfer += $input->readString($elem591); + $this->success []= $elem591; } $xfer += $input->readListEnd(); } else { @@ -16617,9 +17382,9 @@ class ThriftHiveMetastore_get_partition_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter557) + foreach ($this->success as $iter592) { - $xfer += $output->writeString($iter557); + $xfer += $output->writeString($iter592); } } $output->writeListEnd(); @@ -16723,14 +17488,14 @@ class ThriftHiveMetastore_get_partitions_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size558 = 0; - $_etype561 = 0; - $xfer += $input->readListBegin($_etype561, $_size558); - for ($_i562 = 0; $_i562 < $_size558; ++$_i562) + $_size593 = 0; + $_etype596 = 0; + $xfer += $input->readListBegin($_etype596, $_size593); + for ($_i597 = 0; $_i597 < $_size593; ++$_i597) { - $elem563 = null; - $xfer += $input->readString($elem563); - $this->part_vals []= $elem563; + $elem598 = null; + $xfer += $input->readString($elem598); + $this->part_vals []= $elem598; } $xfer += $input->readListEnd(); } else { @@ -16775,9 +17540,9 @@ class ThriftHiveMetastore_get_partitions_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter564) + foreach ($this->part_vals as $iter599) { - $xfer += $output->writeString($iter564); + $xfer += $output->writeString($iter599); } } $output->writeListEnd(); @@ -16862,15 +17627,15 @@ class ThriftHiveMetastore_get_partitions_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size565 = 0; - $_etype568 = 0; - $xfer += $input->readListBegin($_etype568, $_size565); - for ($_i569 = 0; $_i569 < $_size565; ++$_i569) + $_size600 = 0; + $_etype603 = 0; + $xfer += $input->readListBegin($_etype603, $_size600); + for ($_i604 = 0; $_i604 < $_size600; ++$_i604) { - $elem570 = null; - $elem570 = new \metastore\Partition(); - $xfer += $elem570->read($input); - $this->success []= $elem570; + $elem605 = null; + $elem605 = new \metastore\Partition(); + $xfer += $elem605->read($input); + $this->success []= $elem605; } $xfer += $input->readListEnd(); } else { @@ -16914,9 +17679,9 @@ class ThriftHiveMetastore_get_partitions_ps_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter571) + foreach ($this->success as $iter606) { - $xfer += $iter571->write($output); + $xfer += $iter606->write($output); } } $output->writeListEnd(); @@ -17045,14 +17810,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size572 = 0; - $_etype575 = 0; - $xfer += $input->readListBegin($_etype575, $_size572); - for ($_i576 = 0; $_i576 < $_size572; ++$_i576) + $_size607 = 0; + $_etype610 = 0; + $xfer += $input->readListBegin($_etype610, $_size607); + for ($_i611 = 0; $_i611 < $_size607; ++$_i611) { - $elem577 = null; - $xfer += $input->readString($elem577); - $this->part_vals []= $elem577; + $elem612 = null; + $xfer += $input->readString($elem612); + $this->part_vals []= $elem612; } $xfer += $input->readListEnd(); } else { @@ -17076,14 +17841,14 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { case 6: if ($ftype == TType::LST) { $this->group_names = array(); - $_size578 = 0; - $_etype581 = 0; - $xfer += $input->readListBegin($_etype581, $_size578); - for ($_i582 = 0; $_i582 < $_size578; ++$_i582) + $_size613 = 0; + $_etype616 = 0; + $xfer += $input->readListBegin($_etype616, $_size613); + for ($_i617 = 0; $_i617 < $_size613; ++$_i617) { - $elem583 = null; - $xfer += $input->readString($elem583); - $this->group_names []= $elem583; + $elem618 = null; + $xfer += $input->readString($elem618); + $this->group_names []= $elem618; } $xfer += $input->readListEnd(); } else { @@ -17121,9 +17886,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter584) + foreach ($this->part_vals as $iter619) { - $xfer += $output->writeString($iter584); + $xfer += $output->writeString($iter619); } } $output->writeListEnd(); @@ -17148,9 +17913,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter585) + foreach ($this->group_names as $iter620) { - $xfer += $output->writeString($iter585); + $xfer += $output->writeString($iter620); } } $output->writeListEnd(); @@ -17230,15 +17995,15 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size586 = 0; - $_etype589 = 0; - $xfer += $input->readListBegin($_etype589, $_size586); - for ($_i590 = 0; $_i590 < $_size586; ++$_i590) + $_size621 = 0; + $_etype624 = 0; + $xfer += $input->readListBegin($_etype624, $_size621); + for ($_i625 = 0; $_i625 < $_size621; ++$_i625) { - $elem591 = null; - $elem591 = new \metastore\Partition(); - $xfer += $elem591->read($input); - $this->success []= $elem591; + $elem626 = null; + $elem626 = new \metastore\Partition(); + $xfer += $elem626->read($input); + $this->success []= $elem626; } $xfer += $input->readListEnd(); } else { @@ -17282,9 +18047,9 @@ class ThriftHiveMetastore_get_partitions_ps_with_auth_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter592) + foreach ($this->success as $iter627) { - $xfer += $iter592->write($output); + $xfer += $iter627->write($output); } } $output->writeListEnd(); @@ -17393,14 +18158,14 @@ class ThriftHiveMetastore_get_partition_names_ps_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size593 = 0; - $_etype596 = 0; - $xfer += $input->readListBegin($_etype596, $_size593); - for ($_i597 = 0; $_i597 < $_size593; ++$_i597) + $_size628 = 0; + $_etype631 = 0; + $xfer += $input->readListBegin($_etype631, $_size628); + for ($_i632 = 0; $_i632 < $_size628; ++$_i632) { - $elem598 = null; - $xfer += $input->readString($elem598); - $this->part_vals []= $elem598; + $elem633 = null; + $xfer += $input->readString($elem633); + $this->part_vals []= $elem633; } $xfer += $input->readListEnd(); } else { @@ -17445,9 +18210,9 @@ class ThriftHiveMetastore_get_partition_names_ps_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter599) + foreach ($this->part_vals as $iter634) { - $xfer += $output->writeString($iter599); + $xfer += $output->writeString($iter634); } } $output->writeListEnd(); @@ -17531,14 +18296,14 @@ class ThriftHiveMetastore_get_partition_names_ps_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size600 = 0; - $_etype603 = 0; - $xfer += $input->readListBegin($_etype603, $_size600); - for ($_i604 = 0; $_i604 < $_size600; ++$_i604) + $_size635 = 0; + $_etype638 = 0; + $xfer += $input->readListBegin($_etype638, $_size635); + for ($_i639 = 0; $_i639 < $_size635; ++$_i639) { - $elem605 = null; - $xfer += $input->readString($elem605); - $this->success []= $elem605; + $elem640 = null; + $xfer += $input->readString($elem640); + $this->success []= $elem640; } $xfer += $input->readListEnd(); } else { @@ -17582,9 +18347,9 @@ class ThriftHiveMetastore_get_partition_names_ps_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter606) + foreach ($this->success as $iter641) { - $xfer += $output->writeString($iter606); + $xfer += $output->writeString($iter641); } } $output->writeListEnd(); @@ -17806,15 +18571,15 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size607 = 0; - $_etype610 = 0; - $xfer += $input->readListBegin($_etype610, $_size607); - for ($_i611 = 0; $_i611 < $_size607; ++$_i611) + $_size642 = 0; + $_etype645 = 0; + $xfer += $input->readListBegin($_etype645, $_size642); + for ($_i646 = 0; $_i646 < $_size642; ++$_i646) { - $elem612 = null; - $elem612 = new \metastore\Partition(); - $xfer += $elem612->read($input); - $this->success []= $elem612; + $elem647 = null; + $elem647 = new \metastore\Partition(); + $xfer += $elem647->read($input); + $this->success []= $elem647; } $xfer += $input->readListEnd(); } else { @@ -17858,9 +18623,9 @@ class ThriftHiveMetastore_get_partitions_by_filter_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter613) + foreach ($this->success as $iter648) { - $xfer += $iter613->write($output); + $xfer += $iter648->write($output); } } $output->writeListEnd(); @@ -18159,14 +18924,14 @@ class ThriftHiveMetastore_get_partitions_by_names_args { case 3: if ($ftype == TType::LST) { $this->names = array(); - $_size614 = 0; - $_etype617 = 0; - $xfer += $input->readListBegin($_etype617, $_size614); - for ($_i618 = 0; $_i618 < $_size614; ++$_i618) + $_size649 = 0; + $_etype652 = 0; + $xfer += $input->readListBegin($_etype652, $_size649); + for ($_i653 = 0; $_i653 < $_size649; ++$_i653) { - $elem619 = null; - $xfer += $input->readString($elem619); - $this->names []= $elem619; + $elem654 = null; + $xfer += $input->readString($elem654); + $this->names []= $elem654; } $xfer += $input->readListEnd(); } else { @@ -18204,9 +18969,9 @@ class ThriftHiveMetastore_get_partitions_by_names_args { { $output->writeListBegin(TType::STRING, count($this->names)); { - foreach ($this->names as $iter620) + foreach ($this->names as $iter655) { - $xfer += $output->writeString($iter620); + $xfer += $output->writeString($iter655); } } $output->writeListEnd(); @@ -18286,15 +19051,15 @@ class ThriftHiveMetastore_get_partitions_by_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size621 = 0; - $_etype624 = 0; - $xfer += $input->readListBegin($_etype624, $_size621); - for ($_i625 = 0; $_i625 < $_size621; ++$_i625) + $_size656 = 0; + $_etype659 = 0; + $xfer += $input->readListBegin($_etype659, $_size656); + for ($_i660 = 0; $_i660 < $_size656; ++$_i660) { - $elem626 = null; - $elem626 = new \metastore\Partition(); - $xfer += $elem626->read($input); - $this->success []= $elem626; + $elem661 = null; + $elem661 = new \metastore\Partition(); + $xfer += $elem661->read($input); + $this->success []= $elem661; } $xfer += $input->readListEnd(); } else { @@ -18338,9 +19103,9 @@ class ThriftHiveMetastore_get_partitions_by_names_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter627) + foreach ($this->success as $iter662) { - $xfer += $iter627->write($output); + $xfer += $iter662->write($output); } } $output->writeListEnd(); @@ -18655,15 +19420,15 @@ class ThriftHiveMetastore_alter_partitions_args { case 3: if ($ftype == TType::LST) { $this->new_parts = array(); - $_size628 = 0; - $_etype631 = 0; - $xfer += $input->readListBegin($_etype631, $_size628); - for ($_i632 = 0; $_i632 < $_size628; ++$_i632) + $_size663 = 0; + $_etype666 = 0; + $xfer += $input->readListBegin($_etype666, $_size663); + for ($_i667 = 0; $_i667 < $_size663; ++$_i667) { - $elem633 = null; - $elem633 = new \metastore\Partition(); - $xfer += $elem633->read($input); - $this->new_parts []= $elem633; + $elem668 = null; + $elem668 = new \metastore\Partition(); + $xfer += $elem668->read($input); + $this->new_parts []= $elem668; } $xfer += $input->readListEnd(); } else { @@ -18701,9 +19466,9 @@ class ThriftHiveMetastore_alter_partitions_args { { $output->writeListBegin(TType::STRUCT, count($this->new_parts)); { - foreach ($this->new_parts as $iter634) + foreach ($this->new_parts as $iter669) { - $xfer += $iter634->write($output); + $xfer += $iter669->write($output); } } $output->writeListEnd(); @@ -19137,14 +19902,14 @@ class ThriftHiveMetastore_rename_partition_args { case 3: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size635 = 0; - $_etype638 = 0; - $xfer += $input->readListBegin($_etype638, $_size635); - for ($_i639 = 0; $_i639 < $_size635; ++$_i639) + $_size670 = 0; + $_etype673 = 0; + $xfer += $input->readListBegin($_etype673, $_size670); + for ($_i674 = 0; $_i674 < $_size670; ++$_i674) { - $elem640 = null; - $xfer += $input->readString($elem640); - $this->part_vals []= $elem640; + $elem675 = null; + $xfer += $input->readString($elem675); + $this->part_vals []= $elem675; } $xfer += $input->readListEnd(); } else { @@ -19190,9 +19955,9 @@ class ThriftHiveMetastore_rename_partition_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter641) + foreach ($this->part_vals as $iter676) { - $xfer += $output->writeString($iter641); + $xfer += $output->writeString($iter676); } } $output->writeListEnd(); @@ -19365,14 +20130,14 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { case 1: if ($ftype == TType::LST) { $this->part_vals = array(); - $_size642 = 0; - $_etype645 = 0; - $xfer += $input->readListBegin($_etype645, $_size642); - for ($_i646 = 0; $_i646 < $_size642; ++$_i646) + $_size677 = 0; + $_etype680 = 0; + $xfer += $input->readListBegin($_etype680, $_size677); + for ($_i681 = 0; $_i681 < $_size677; ++$_i681) { - $elem647 = null; - $xfer += $input->readString($elem647); - $this->part_vals []= $elem647; + $elem682 = null; + $xfer += $input->readString($elem682); + $this->part_vals []= $elem682; } $xfer += $input->readListEnd(); } else { @@ -19407,9 +20172,9 @@ class ThriftHiveMetastore_partition_name_has_valid_characters_args { { $output->writeListBegin(TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $iter648) + foreach ($this->part_vals as $iter683) { - $xfer += $output->writeString($iter648); + $xfer += $output->writeString($iter683); } } $output->writeListEnd(); @@ -19836,14 +20601,14 @@ class ThriftHiveMetastore_partition_name_to_vals_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size649 = 0; - $_etype652 = 0; - $xfer += $input->readListBegin($_etype652, $_size649); - for ($_i653 = 0; $_i653 < $_size649; ++$_i653) + $_size684 = 0; + $_etype687 = 0; + $xfer += $input->readListBegin($_etype687, $_size684); + for ($_i688 = 0; $_i688 < $_size684; ++$_i688) { - $elem654 = null; - $xfer += $input->readString($elem654); - $this->success []= $elem654; + $elem689 = null; + $xfer += $input->readString($elem689); + $this->success []= $elem689; } $xfer += $input->readListEnd(); } else { @@ -19879,9 +20644,9 @@ class ThriftHiveMetastore_partition_name_to_vals_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter655) + foreach ($this->success as $iter690) { - $xfer += $output->writeString($iter655); + $xfer += $output->writeString($iter690); } } $output->writeListEnd(); @@ -20032,17 +20797,17 @@ class ThriftHiveMetastore_partition_name_to_spec_result { case 0: if ($ftype == TType::MAP) { $this->success = array(); - $_size656 = 0; - $_ktype657 = 0; - $_vtype658 = 0; - $xfer += $input->readMapBegin($_ktype657, $_vtype658, $_size656); - for ($_i660 = 0; $_i660 < $_size656; ++$_i660) + $_size691 = 0; + $_ktype692 = 0; + $_vtype693 = 0; + $xfer += $input->readMapBegin($_ktype692, $_vtype693, $_size691); + for ($_i695 = 0; $_i695 < $_size691; ++$_i695) { - $key661 = ''; - $val662 = ''; - $xfer += $input->readString($key661); - $xfer += $input->readString($val662); - $this->success[$key661] = $val662; + $key696 = ''; + $val697 = ''; + $xfer += $input->readString($key696); + $xfer += $input->readString($val697); + $this->success[$key696] = $val697; } $xfer += $input->readMapEnd(); } else { @@ -20078,10 +20843,10 @@ class ThriftHiveMetastore_partition_name_to_spec_result { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->success)); { - foreach ($this->success as $kiter663 => $viter664) + foreach ($this->success as $kiter698 => $viter699) { - $xfer += $output->writeString($kiter663); - $xfer += $output->writeString($viter664); + $xfer += $output->writeString($kiter698); + $xfer += $output->writeString($viter699); } } $output->writeMapEnd(); @@ -20189,17 +20954,17 @@ class ThriftHiveMetastore_markPartitionForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size665 = 0; - $_ktype666 = 0; - $_vtype667 = 0; - $xfer += $input->readMapBegin($_ktype666, $_vtype667, $_size665); - for ($_i669 = 0; $_i669 < $_size665; ++$_i669) + $_size700 = 0; + $_ktype701 = 0; + $_vtype702 = 0; + $xfer += $input->readMapBegin($_ktype701, $_vtype702, $_size700); + for ($_i704 = 0; $_i704 < $_size700; ++$_i704) { - $key670 = ''; - $val671 = ''; - $xfer += $input->readString($key670); - $xfer += $input->readString($val671); - $this->part_vals[$key670] = $val671; + $key705 = ''; + $val706 = ''; + $xfer += $input->readString($key705); + $xfer += $input->readString($val706); + $this->part_vals[$key705] = $val706; } $xfer += $input->readMapEnd(); } else { @@ -20244,10 +21009,10 @@ class ThriftHiveMetastore_markPartitionForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter672 => $viter673) + foreach ($this->part_vals as $kiter707 => $viter708) { - $xfer += $output->writeString($kiter672); - $xfer += $output->writeString($viter673); + $xfer += $output->writeString($kiter707); + $xfer += $output->writeString($viter708); } } $output->writeMapEnd(); @@ -20539,17 +21304,17 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { case 3: if ($ftype == TType::MAP) { $this->part_vals = array(); - $_size674 = 0; - $_ktype675 = 0; - $_vtype676 = 0; - $xfer += $input->readMapBegin($_ktype675, $_vtype676, $_size674); - for ($_i678 = 0; $_i678 < $_size674; ++$_i678) + $_size709 = 0; + $_ktype710 = 0; + $_vtype711 = 0; + $xfer += $input->readMapBegin($_ktype710, $_vtype711, $_size709); + for ($_i713 = 0; $_i713 < $_size709; ++$_i713) { - $key679 = ''; - $val680 = ''; - $xfer += $input->readString($key679); - $xfer += $input->readString($val680); - $this->part_vals[$key679] = $val680; + $key714 = ''; + $val715 = ''; + $xfer += $input->readString($key714); + $xfer += $input->readString($val715); + $this->part_vals[$key714] = $val715; } $xfer += $input->readMapEnd(); } else { @@ -20594,10 +21359,10 @@ class ThriftHiveMetastore_isPartitionMarkedForEvent_args { { $output->writeMapBegin(TType::STRING, TType::STRING, count($this->part_vals)); { - foreach ($this->part_vals as $kiter681 => $viter682) + foreach ($this->part_vals as $kiter716 => $viter717) { - $xfer += $output->writeString($kiter681); - $xfer += $output->writeString($viter682); + $xfer += $output->writeString($kiter716); + $xfer += $output->writeString($viter717); } } $output->writeMapEnd(); @@ -21957,15 +22722,15 @@ class ThriftHiveMetastore_get_indexes_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) + $_size718 = 0; + $_etype721 = 0; + $xfer += $input->readListBegin($_etype721, $_size718); + for ($_i722 = 0; $_i722 < $_size718; ++$_i722) { - $elem688 = null; - $elem688 = new \metastore\Index(); - $xfer += $elem688->read($input); - $this->success []= $elem688; + $elem723 = null; + $elem723 = new \metastore\Index(); + $xfer += $elem723->read($input); + $this->success []= $elem723; } $xfer += $input->readListEnd(); } else { @@ -22009,9 +22774,9 @@ class ThriftHiveMetastore_get_indexes_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter689) + foreach ($this->success as $iter724) { - $xfer += $iter689->write($output); + $xfer += $iter724->write($output); } } $output->writeListEnd(); @@ -22203,14 +22968,14 @@ class ThriftHiveMetastore_get_index_names_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size690 = 0; - $_etype693 = 0; - $xfer += $input->readListBegin($_etype693, $_size690); - for ($_i694 = 0; $_i694 < $_size690; ++$_i694) + $_size725 = 0; + $_etype728 = 0; + $xfer += $input->readListBegin($_etype728, $_size725); + for ($_i729 = 0; $_i729 < $_size725; ++$_i729) { - $elem695 = null; - $xfer += $input->readString($elem695); - $this->success []= $elem695; + $elem730 = null; + $xfer += $input->readString($elem730); + $this->success []= $elem730; } $xfer += $input->readListEnd(); } else { @@ -22246,9 +23011,9 @@ class ThriftHiveMetastore_get_index_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter696) + foreach ($this->success as $iter731) { - $xfer += $output->writeString($iter696); + $xfer += $output->writeString($iter731); } } $output->writeListEnd(); @@ -25041,14 +25806,14 @@ class ThriftHiveMetastore_get_functions_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) + $_size732 = 0; + $_etype735 = 0; + $xfer += $input->readListBegin($_etype735, $_size732); + for ($_i736 = 0; $_i736 < $_size732; ++$_i736) { - $elem702 = null; - $xfer += $input->readString($elem702); - $this->success []= $elem702; + $elem737 = null; + $xfer += $input->readString($elem737); + $this->success []= $elem737; } $xfer += $input->readListEnd(); } else { @@ -25084,9 +25849,9 @@ class ThriftHiveMetastore_get_functions_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter703) + foreach ($this->success as $iter738) { - $xfer += $output->writeString($iter703); + $xfer += $output->writeString($iter738); } } $output->writeListEnd(); @@ -25761,14 +26526,14 @@ class ThriftHiveMetastore_get_role_names_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) + $_size739 = 0; + $_etype742 = 0; + $xfer += $input->readListBegin($_etype742, $_size739); + for ($_i743 = 0; $_i743 < $_size739; ++$_i743) { - $elem709 = null; - $xfer += $input->readString($elem709); - $this->success []= $elem709; + $elem744 = null; + $xfer += $input->readString($elem744); + $this->success []= $elem744; } $xfer += $input->readListEnd(); } else { @@ -25804,9 +26569,9 @@ class ThriftHiveMetastore_get_role_names_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter710) + foreach ($this->success as $iter745) { - $xfer += $output->writeString($iter710); + $xfer += $output->writeString($iter745); } } $output->writeListEnd(); @@ -26446,15 +27211,15 @@ class ThriftHiveMetastore_list_roles_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) + $_size746 = 0; + $_etype749 = 0; + $xfer += $input->readListBegin($_etype749, $_size746); + for ($_i750 = 0; $_i750 < $_size746; ++$_i750) { - $elem716 = null; - $elem716 = new \metastore\Role(); - $xfer += $elem716->read($input); - $this->success []= $elem716; + $elem751 = null; + $elem751 = new \metastore\Role(); + $xfer += $elem751->read($input); + $this->success []= $elem751; } $xfer += $input->readListEnd(); } else { @@ -26490,9 +27255,9 @@ class ThriftHiveMetastore_list_roles_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter717) + foreach ($this->success as $iter752) { - $xfer += $iter717->write($output); + $xfer += $iter752->write($output); } } $output->writeListEnd(); @@ -26942,14 +27707,14 @@ class ThriftHiveMetastore_get_privilege_set_args { case 3: if ($ftype == TType::LST) { $this->group_names = array(); - $_size718 = 0; - $_etype721 = 0; - $xfer += $input->readListBegin($_etype721, $_size718); - for ($_i722 = 0; $_i722 < $_size718; ++$_i722) + $_size753 = 0; + $_etype756 = 0; + $xfer += $input->readListBegin($_etype756, $_size753); + for ($_i757 = 0; $_i757 < $_size753; ++$_i757) { - $elem723 = null; - $xfer += $input->readString($elem723); - $this->group_names []= $elem723; + $elem758 = null; + $xfer += $input->readString($elem758); + $this->group_names []= $elem758; } $xfer += $input->readListEnd(); } else { @@ -26990,9 +27755,9 @@ class ThriftHiveMetastore_get_privilege_set_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter724) + foreach ($this->group_names as $iter759) { - $xfer += $output->writeString($iter724); + $xfer += $output->writeString($iter759); } } $output->writeListEnd(); @@ -27279,15 +28044,15 @@ class ThriftHiveMetastore_list_privileges_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) + $_size760 = 0; + $_etype763 = 0; + $xfer += $input->readListBegin($_etype763, $_size760); + for ($_i764 = 0; $_i764 < $_size760; ++$_i764) { - $elem730 = null; - $elem730 = new \metastore\HiveObjectPrivilege(); - $xfer += $elem730->read($input); - $this->success []= $elem730; + $elem765 = null; + $elem765 = new \metastore\HiveObjectPrivilege(); + $xfer += $elem765->read($input); + $this->success []= $elem765; } $xfer += $input->readListEnd(); } else { @@ -27323,9 +28088,9 @@ class ThriftHiveMetastore_list_privileges_result { { $output->writeListBegin(TType::STRUCT, count($this->success)); { - foreach ($this->success as $iter731) + foreach ($this->success as $iter766) { - $xfer += $iter731->write($output); + $xfer += $iter766->write($output); } } $output->writeListEnd(); @@ -27748,14 +28513,14 @@ class ThriftHiveMetastore_set_ugi_args { case 2: if ($ftype == TType::LST) { $this->group_names = array(); - $_size732 = 0; - $_etype735 = 0; - $xfer += $input->readListBegin($_etype735, $_size732); - for ($_i736 = 0; $_i736 < $_size732; ++$_i736) + $_size767 = 0; + $_etype770 = 0; + $xfer += $input->readListBegin($_etype770, $_size767); + for ($_i771 = 0; $_i771 < $_size767; ++$_i771) { - $elem737 = null; - $xfer += $input->readString($elem737); - $this->group_names []= $elem737; + $elem772 = null; + $xfer += $input->readString($elem772); + $this->group_names []= $elem772; } $xfer += $input->readListEnd(); } else { @@ -27788,9 +28553,9 @@ class ThriftHiveMetastore_set_ugi_args { { $output->writeListBegin(TType::STRING, count($this->group_names)); { - foreach ($this->group_names as $iter738) + foreach ($this->group_names as $iter773) { - $xfer += $output->writeString($iter738); + $xfer += $output->writeString($iter773); } } $output->writeListEnd(); @@ -27860,14 +28625,14 @@ class ThriftHiveMetastore_set_ugi_result { case 0: if ($ftype == TType::LST) { $this->success = array(); - $_size739 = 0; - $_etype742 = 0; - $xfer += $input->readListBegin($_etype742, $_size739); - for ($_i743 = 0; $_i743 < $_size739; ++$_i743) + $_size774 = 0; + $_etype777 = 0; + $xfer += $input->readListBegin($_etype777, $_size774); + for ($_i778 = 0; $_i778 < $_size774; ++$_i778) { - $elem744 = null; - $xfer += $input->readString($elem744); - $this->success []= $elem744; + $elem779 = null; + $xfer += $input->readString($elem779); + $this->success []= $elem779; } $xfer += $input->readListEnd(); } else { @@ -27903,9 +28668,9 @@ class ThriftHiveMetastore_set_ugi_result { { $output->writeListBegin(TType::STRING, count($this->success)); { - foreach ($this->success as $iter745) + foreach ($this->success as $iter780) { - $xfer += $output->writeString($iter745); + $xfer += $output->writeString($iter780); } } $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 old mode 100644 new mode 100755 index fdedb57..42f6e6c --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -54,6 +54,8 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print ' Partition append_partition_with_environment_context(string db_name, string tbl_name, part_vals, EnvironmentContext environment_context)' print ' Partition append_partition_by_name(string db_name, string tbl_name, string part_name)' print ' Partition append_partition_by_name_with_environment_context(string db_name, string tbl_name, string part_name, EnvironmentContext environment_context)' + print ' bool add_drop_partitions(string db_name, string tbl_name, add_parts, drop_part_vals, bool deleteData)' + print ' bool drop_partitions(string db_name, string tbl_name, part_vals, bool deleteData)' print ' bool drop_partition(string db_name, string tbl_name, part_vals, bool deleteData)' print ' bool drop_partition_with_environment_context(string db_name, string tbl_name, part_vals, bool deleteData, EnvironmentContext environment_context)' print ' bool drop_partition_by_name(string db_name, string tbl_name, string part_name, bool deleteData)' @@ -367,6 +369,18 @@ elif cmd == 'append_partition_by_name_with_environment_context': sys.exit(1) pp.pprint(client.append_partition_by_name_with_environment_context(args[0],args[1],args[2],eval(args[3]),)) +elif cmd == 'add_drop_partitions': + if len(args) != 5: + print 'add_drop_partitions requires 5 args' + sys.exit(1) + pp.pprint(client.add_drop_partitions(args[0],args[1],eval(args[2]),eval(args[3]),eval(args[4]),)) + +elif cmd == 'drop_partitions': + if len(args) != 4: + print 'drop_partitions requires 4 args' + sys.exit(1) + pp.pprint(client.drop_partitions(args[0],args[1],eval(args[2]),eval(args[3]),)) + elif cmd == 'drop_partition': if len(args) != 4: print 'drop_partition requires 4 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 23679be..19d31b8 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -267,6 +267,27 @@ def append_partition_by_name_with_environment_context(self, db_name, tbl_name, p """ pass + def add_drop_partitions(self, db_name, tbl_name, add_parts, drop_part_vals, deleteData): + """ + Parameters: + - db_name + - tbl_name + - add_parts + - drop_part_vals + - deleteData + """ + pass + + def drop_partitions(self, db_name, tbl_name, part_vals, deleteData): + """ + Parameters: + - db_name + - tbl_name + - part_vals + - deleteData + """ + pass + def drop_partition(self, db_name, tbl_name, part_vals, deleteData): """ Parameters: @@ -2028,6 +2049,88 @@ def recv_append_partition_by_name_with_environment_context(self, ): raise result.o3 raise TApplicationException(TApplicationException.MISSING_RESULT, "append_partition_by_name_with_environment_context failed: unknown result"); + def add_drop_partitions(self, db_name, tbl_name, add_parts, drop_part_vals, deleteData): + """ + Parameters: + - db_name + - tbl_name + - add_parts + - drop_part_vals + - deleteData + """ + self.send_add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData) + return self.recv_add_drop_partitions() + + def send_add_drop_partitions(self, db_name, tbl_name, add_parts, drop_part_vals, deleteData): + self._oprot.writeMessageBegin('add_drop_partitions', TMessageType.CALL, self._seqid) + args = add_drop_partitions_args() + args.db_name = db_name + args.tbl_name = tbl_name + args.add_parts = add_parts + args.drop_part_vals = drop_part_vals + args.deleteData = deleteData + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_add_drop_partitions(self, ): + (fname, mtype, rseqid) = self._iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(self._iprot) + self._iprot.readMessageEnd() + raise x + result = add_drop_partitions_result() + result.read(self._iprot) + self._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, "add_drop_partitions failed: unknown result"); + + def drop_partitions(self, db_name, tbl_name, part_vals, deleteData): + """ + Parameters: + - db_name + - tbl_name + - part_vals + - deleteData + """ + self.send_drop_partitions(db_name, tbl_name, part_vals, deleteData) + return self.recv_drop_partitions() + + def send_drop_partitions(self, db_name, tbl_name, part_vals, deleteData): + self._oprot.writeMessageBegin('drop_partitions', TMessageType.CALL, self._seqid) + args = drop_partitions_args() + args.db_name = db_name + args.tbl_name = tbl_name + args.part_vals = part_vals + args.deleteData = deleteData + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_partitions(self, ): + (fname, mtype, rseqid) = self._iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(self._iprot) + self._iprot.readMessageEnd() + raise x + result = drop_partitions_result() + result.read(self._iprot) + self._iprot.readMessageEnd() + if result.success is not None: + return result.success + raise TApplicationException(TApplicationException.MISSING_RESULT, "drop_partitions failed: unknown result"); + def drop_partition(self, db_name, tbl_name, part_vals, deleteData): """ Parameters: @@ -4800,6 +4903,8 @@ def __init__(self, handler): self._processMap["append_partition_with_environment_context"] = Processor.process_append_partition_with_environment_context self._processMap["append_partition_by_name"] = Processor.process_append_partition_by_name self._processMap["append_partition_by_name_with_environment_context"] = Processor.process_append_partition_by_name_with_environment_context + self._processMap["add_drop_partitions"] = Processor.process_add_drop_partitions + self._processMap["drop_partitions"] = Processor.process_drop_partitions self._processMap["drop_partition"] = Processor.process_drop_partition self._processMap["drop_partition_with_environment_context"] = Processor.process_drop_partition_with_environment_context self._processMap["drop_partition_by_name"] = Processor.process_drop_partition_by_name @@ -5416,6 +5521,37 @@ def process_append_partition_by_name_with_environment_context(self, seqid, iprot oprot.writeMessageEnd() oprot.trans.flush() + def process_add_drop_partitions(self, seqid, iprot, oprot): + args = add_drop_partitions_args() + args.read(iprot) + iprot.readMessageEnd() + result = add_drop_partitions_result() + try: + result.success = self._handler.add_drop_partitions(args.db_name, args.tbl_name, args.add_parts, args.drop_part_vals, args.deleteData) + except InvalidObjectException as o1: + result.o1 = o1 + except AlreadyExistsException as o2: + result.o2 = o2 + except NoSuchObjectException as o3: + result.o3 = o3 + except MetaException as o4: + result.o4 = o4 + oprot.writeMessageBegin("add_drop_partitions", TMessageType.REPLY, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_partitions(self, seqid, iprot, oprot): + args = drop_partitions_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_partitions_result() + result.success = self._handler.drop_partitions(args.db_name, args.tbl_name, args.part_vals, args.deleteData) + oprot.writeMessageBegin("drop_partitions", TMessageType.REPLY, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_drop_partition(self, seqid, iprot, oprot): args = drop_partition_args() args.read(iprot) @@ -11687,12 +11823,13 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_args: +class add_drop_partitions_args: """ Attributes: - db_name - tbl_name - - part_vals + - add_parts + - drop_part_vals - deleteData """ @@ -11700,14 +11837,16 @@ class drop_partition_args: None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3 - (4, TType.BOOL, 'deleteData', None, None, ), # 4 + (3, TType.LIST, 'add_parts', (TType.STRUCT,(Partition, Partition.thrift_spec)), None, ), # 3 + (4, TType.LIST, 'drop_part_vals', (TType.LIST,(TType.STRING,None)), None, ), # 4 + (5, TType.BOOL, 'deleteData', None, None, ), # 5 ) - def __init__(self, db_name=None, tbl_name=None, part_vals=None, deleteData=None,): + def __init__(self, db_name=None, tbl_name=None, add_parts=None, drop_part_vals=None, deleteData=None,): self.db_name = db_name self.tbl_name = tbl_name - self.part_vals = part_vals + self.add_parts = add_parts + self.drop_part_vals = drop_part_vals self.deleteData = deleteData def read(self, iprot): @@ -11731,15 +11870,31 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: - self.part_vals = [] + self.add_parts = [] (_etype486, _size483) = iprot.readListBegin() for _i487 in xrange(_size483): - _elem488 = iprot.readString(); - self.part_vals.append(_elem488) + _elem488 = Partition() + _elem488.read(iprot) + self.add_parts.append(_elem488) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: + if ftype == TType.LIST: + self.drop_part_vals = [] + (_etype492, _size489) = iprot.readListBegin() + for _i493 in xrange(_size489): + _elem494 = [] + (_etype498, _size495) = iprot.readListBegin() + for _i499 in xrange(_size495): + _elem500 = iprot.readString(); + _elem494.append(_elem500) + iprot.readListEnd() + self.drop_part_vals.append(_elem494) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 5: if ftype == TType.BOOL: self.deleteData = iprot.readBool(); else: @@ -11753,7 +11908,7 @@ 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('drop_partition_args') + oprot.writeStructBegin('add_drop_partitions_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -11762,15 +11917,25 @@ def write(self, oprot): oprot.writeFieldBegin('tbl_name', TType.STRING, 2) oprot.writeString(self.tbl_name) oprot.writeFieldEnd() - if self.part_vals is not None: - oprot.writeFieldBegin('part_vals', TType.LIST, 3) - oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter489 in self.part_vals: - oprot.writeString(iter489) + if self.add_parts is not None: + oprot.writeFieldBegin('add_parts', TType.LIST, 3) + oprot.writeListBegin(TType.STRUCT, len(self.add_parts)) + for iter501 in self.add_parts: + iter501.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.drop_part_vals is not None: + oprot.writeFieldBegin('drop_part_vals', TType.LIST, 4) + oprot.writeListBegin(TType.LIST, len(self.drop_part_vals)) + for iter502 in self.drop_part_vals: + oprot.writeListBegin(TType.STRING, len(iter502)) + for iter503 in iter502: + oprot.writeString(iter503) + oprot.writeListEnd() oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: - oprot.writeFieldBegin('deleteData', TType.BOOL, 4) + oprot.writeFieldBegin('deleteData', TType.BOOL, 5) oprot.writeBool(self.deleteData) oprot.writeFieldEnd() oprot.writeFieldStop() @@ -11791,24 +11956,30 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_result: +class add_drop_partitions_result: """ Attributes: - success - o1 - o2 + - o3 + - o4 """ thrift_spec = ( (0, TType.BOOL, 'success', None, None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 + (1, TType.STRUCT, 'o1', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (AlreadyExistsException, AlreadyExistsException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (MetaException, MetaException.thrift_spec), None, ), # 4 ) - def __init__(self, success=None, o1=None, o2=None,): + 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: @@ -11826,16 +11997,28 @@ def read(self, iprot): iprot.skip(ftype) elif fid == 1: if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() + self.o1 = InvalidObjectException() self.o1.read(iprot) else: iprot.skip(ftype) elif fid == 2: if ftype == TType.STRUCT: - self.o2 = MetaException() + self.o2 = AlreadyExistsException() self.o2.read(iprot) else: iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = NoSuchObjectException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = MetaException() + self.o4.read(iprot) + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -11845,7 +12028,7 @@ 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('drop_partition_result') + oprot.writeStructBegin('add_drop_partitions_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) @@ -11858,6 +12041,14 @@ def write(self, oprot): 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() @@ -11876,31 +12067,28 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_with_environment_context_args: +class drop_partitions_args: """ Attributes: - db_name - tbl_name - part_vals - deleteData - - environment_context """ thrift_spec = ( None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3 + (3, TType.LIST, 'part_vals', (TType.LIST,(TType.STRING,None)), None, ), # 3 (4, TType.BOOL, 'deleteData', None, None, ), # 4 - (5, TType.STRUCT, 'environment_context', (EnvironmentContext, EnvironmentContext.thrift_spec), None, ), # 5 ) - def __init__(self, db_name=None, tbl_name=None, part_vals=None, deleteData=None, environment_context=None,): + def __init__(self, db_name=None, tbl_name=None, part_vals=None, deleteData=None,): self.db_name = db_name self.tbl_name = tbl_name self.part_vals = part_vals self.deleteData = deleteData - self.environment_context = environment_context 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: @@ -11924,10 +12112,15 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype493, _size490) = iprot.readListBegin() - for _i494 in xrange(_size490): - _elem495 = iprot.readString(); - self.part_vals.append(_elem495) + (_etype507, _size504) = iprot.readListBegin() + for _i508 in xrange(_size504): + _elem509 = [] + (_etype513, _size510) = iprot.readListBegin() + for _i514 in xrange(_size510): + _elem515 = iprot.readString(); + _elem509.append(_elem515) + iprot.readListEnd() + self.part_vals.append(_elem509) iprot.readListEnd() else: iprot.skip(ftype) @@ -11936,12 +12129,6 @@ def read(self, iprot): self.deleteData = iprot.readBool(); else: iprot.skip(ftype) - elif fid == 5: - if ftype == TType.STRUCT: - self.environment_context = EnvironmentContext() - self.environment_context.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -11951,7 +12138,7 @@ 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('drop_partition_with_environment_context_args') + oprot.writeStructBegin('drop_partitions_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -11962,19 +12149,18 @@ def write(self, oprot): oprot.writeFieldEnd() if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) - oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter496 in self.part_vals: - oprot.writeString(iter496) + oprot.writeListBegin(TType.LIST, len(self.part_vals)) + for iter516 in self.part_vals: + oprot.writeListBegin(TType.STRING, len(iter516)) + for iter517 in iter516: + oprot.writeString(iter517) + oprot.writeListEnd() oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: oprot.writeFieldBegin('deleteData', TType.BOOL, 4) oprot.writeBool(self.deleteData) oprot.writeFieldEnd() - if self.environment_context is not None: - oprot.writeFieldBegin('environment_context', TType.STRUCT, 5) - self.environment_context.write(oprot) - oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -11993,24 +12179,18 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_with_environment_context_result: +class drop_partitions_result: """ Attributes: - success - - o1 - - o2 """ thrift_spec = ( (0, TType.BOOL, 'success', None, None, ), # 0 - (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 - (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 ) - def __init__(self, success=None, o1=None, o2=None,): + def __init__(self, success=None,): self.success = success - self.o1 = o1 - self.o2 = o2 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: @@ -12026,18 +12206,6 @@ def read(self, iprot): self.success = iprot.readBool(); else: iprot.skip(ftype) - elif fid == 1: - if ftype == TType.STRUCT: - self.o1 = NoSuchObjectException() - self.o1.read(iprot) - else: - iprot.skip(ftype) - elif fid == 2: - if ftype == TType.STRUCT: - self.o2 = MetaException() - self.o2.read(iprot) - else: - iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -12047,19 +12215,11 @@ 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('drop_partition_with_environment_context_result') + oprot.writeStructBegin('drop_partitions_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) 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() oprot.writeFieldStop() oprot.writeStructEnd() @@ -12078,12 +12238,12 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_by_name_args: +class drop_partition_args: """ Attributes: - db_name - tbl_name - - part_name + - part_vals - deleteData """ @@ -12091,14 +12251,14 @@ class drop_partition_by_name_args: None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'part_name', None, None, ), # 3 + (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3 (4, TType.BOOL, 'deleteData', None, None, ), # 4 ) - def __init__(self, db_name=None, tbl_name=None, part_name=None, deleteData=None,): + def __init__(self, db_name=None, tbl_name=None, part_vals=None, deleteData=None,): self.db_name = db_name self.tbl_name = tbl_name - self.part_name = part_name + self.part_vals = part_vals self.deleteData = deleteData def read(self, iprot): @@ -12121,8 +12281,13 @@ def read(self, iprot): else: iprot.skip(ftype) elif fid == 3: - if ftype == TType.STRING: - self.part_name = iprot.readString(); + if ftype == TType.LIST: + self.part_vals = [] + (_etype521, _size518) = iprot.readListBegin() + for _i522 in xrange(_size518): + _elem523 = iprot.readString(); + self.part_vals.append(_elem523) + iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: @@ -12139,7 +12304,7 @@ 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('drop_partition_by_name_args') + oprot.writeStructBegin('drop_partition_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -12148,9 +12313,12 @@ def write(self, oprot): oprot.writeFieldBegin('tbl_name', TType.STRING, 2) oprot.writeString(self.tbl_name) oprot.writeFieldEnd() - if self.part_name is not None: - oprot.writeFieldBegin('part_name', TType.STRING, 3) - oprot.writeString(self.part_name) + if self.part_vals is not None: + oprot.writeFieldBegin('part_vals', TType.LIST, 3) + oprot.writeListBegin(TType.STRING, len(self.part_vals)) + for iter524 in self.part_vals: + oprot.writeString(iter524) + oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: oprot.writeFieldBegin('deleteData', TType.BOOL, 4) @@ -12174,7 +12342,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_by_name_result: +class drop_partition_result: """ Attributes: - success @@ -12228,7 +12396,7 @@ 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('drop_partition_by_name_result') + oprot.writeStructBegin('drop_partition_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) @@ -12259,12 +12427,12 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_by_name_with_environment_context_args: +class drop_partition_with_environment_context_args: """ Attributes: - db_name - tbl_name - - part_name + - part_vals - deleteData - environment_context """ @@ -12273,15 +12441,15 @@ class drop_partition_by_name_with_environment_context_args: None, # 0 (1, TType.STRING, 'db_name', None, None, ), # 1 (2, TType.STRING, 'tbl_name', None, None, ), # 2 - (3, TType.STRING, 'part_name', None, None, ), # 3 + (3, TType.LIST, 'part_vals', (TType.STRING,None), None, ), # 3 (4, TType.BOOL, 'deleteData', None, None, ), # 4 (5, TType.STRUCT, 'environment_context', (EnvironmentContext, EnvironmentContext.thrift_spec), None, ), # 5 ) - def __init__(self, db_name=None, tbl_name=None, part_name=None, deleteData=None, environment_context=None,): + def __init__(self, db_name=None, tbl_name=None, part_vals=None, deleteData=None, environment_context=None,): self.db_name = db_name self.tbl_name = tbl_name - self.part_name = part_name + self.part_vals = part_vals self.deleteData = deleteData self.environment_context = environment_context @@ -12305,8 +12473,13 @@ def read(self, iprot): else: iprot.skip(ftype) elif fid == 3: - if ftype == TType.STRING: - self.part_name = iprot.readString(); + if ftype == TType.LIST: + self.part_vals = [] + (_etype528, _size525) = iprot.readListBegin() + for _i529 in xrange(_size525): + _elem530 = iprot.readString(); + self.part_vals.append(_elem530) + iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: @@ -12329,7 +12502,7 @@ 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('drop_partition_by_name_with_environment_context_args') + oprot.writeStructBegin('drop_partition_with_environment_context_args') if self.db_name is not None: oprot.writeFieldBegin('db_name', TType.STRING, 1) oprot.writeString(self.db_name) @@ -12338,9 +12511,12 @@ def write(self, oprot): oprot.writeFieldBegin('tbl_name', TType.STRING, 2) oprot.writeString(self.tbl_name) oprot.writeFieldEnd() - if self.part_name is not None: - oprot.writeFieldBegin('part_name', TType.STRING, 3) - oprot.writeString(self.part_name) + if self.part_vals is not None: + oprot.writeFieldBegin('part_vals', TType.LIST, 3) + oprot.writeListBegin(TType.STRING, len(self.part_vals)) + for iter531 in self.part_vals: + oprot.writeString(iter531) + oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: oprot.writeFieldBegin('deleteData', TType.BOOL, 4) @@ -12368,7 +12544,7 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partition_by_name_with_environment_context_result: +class drop_partition_with_environment_context_result: """ Attributes: - success @@ -12422,7 +12598,7 @@ 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('drop_partition_by_name_with_environment_context_result') + oprot.writeStructBegin('drop_partition_with_environment_context_result') if self.success is not None: oprot.writeFieldBegin('success', TType.BOOL, 0) oprot.writeBool(self.success) @@ -12453,7 +12629,382 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) -class drop_partitions_req_args: +class drop_partition_by_name_args: + """ + Attributes: + - db_name + - tbl_name + - part_name + - deleteData + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'db_name', None, None, ), # 1 + (2, TType.STRING, 'tbl_name', None, None, ), # 2 + (3, TType.STRING, 'part_name', None, None, ), # 3 + (4, TType.BOOL, 'deleteData', None, None, ), # 4 + ) + + def __init__(self, db_name=None, tbl_name=None, part_name=None, deleteData=None,): + self.db_name = db_name + self.tbl_name = tbl_name + self.part_name = part_name + self.deleteData = deleteData + + 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.STRING: + self.db_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tbl_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.part_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.BOOL: + self.deleteData = iprot.readBool(); + 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('drop_partition_by_name_args') + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 1) + oprot.writeString(self.db_name) + oprot.writeFieldEnd() + if self.tbl_name is not None: + oprot.writeFieldBegin('tbl_name', TType.STRING, 2) + oprot.writeString(self.tbl_name) + oprot.writeFieldEnd() + if self.part_name is not None: + oprot.writeFieldBegin('part_name', TType.STRING, 3) + oprot.writeString(self.part_name) + oprot.writeFieldEnd() + if self.deleteData is not None: + oprot.writeFieldBegin('deleteData', TType.BOOL, 4) + oprot.writeBool(self.deleteData) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + 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 drop_partition_by_name_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.BOOL, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 + ) + + def __init__(self, success=None, o1=None, o2=None,): + self.success = success + self.o1 = o1 + self.o2 = o2 + + 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.BOOL: + self.success = iprot.readBool(); + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = MetaException() + self.o2.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('drop_partition_by_name_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) + 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() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + 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 drop_partition_by_name_with_environment_context_args: + """ + Attributes: + - db_name + - tbl_name + - part_name + - deleteData + - environment_context + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'db_name', None, None, ), # 1 + (2, TType.STRING, 'tbl_name', None, None, ), # 2 + (3, TType.STRING, 'part_name', None, None, ), # 3 + (4, TType.BOOL, 'deleteData', None, None, ), # 4 + (5, TType.STRUCT, 'environment_context', (EnvironmentContext, EnvironmentContext.thrift_spec), None, ), # 5 + ) + + def __init__(self, db_name=None, tbl_name=None, part_name=None, deleteData=None, environment_context=None,): + self.db_name = db_name + self.tbl_name = tbl_name + self.part_name = part_name + self.deleteData = deleteData + self.environment_context = environment_context + + 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.STRING: + self.db_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.tbl_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.part_name = iprot.readString(); + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.BOOL: + self.deleteData = iprot.readBool(); + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.STRUCT: + self.environment_context = EnvironmentContext() + self.environment_context.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('drop_partition_by_name_with_environment_context_args') + if self.db_name is not None: + oprot.writeFieldBegin('db_name', TType.STRING, 1) + oprot.writeString(self.db_name) + oprot.writeFieldEnd() + if self.tbl_name is not None: + oprot.writeFieldBegin('tbl_name', TType.STRING, 2) + oprot.writeString(self.tbl_name) + oprot.writeFieldEnd() + if self.part_name is not None: + oprot.writeFieldBegin('part_name', TType.STRING, 3) + oprot.writeString(self.part_name) + oprot.writeFieldEnd() + if self.deleteData is not None: + oprot.writeFieldBegin('deleteData', TType.BOOL, 4) + oprot.writeBool(self.deleteData) + oprot.writeFieldEnd() + if self.environment_context is not None: + oprot.writeFieldBegin('environment_context', TType.STRUCT, 5) + self.environment_context.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + 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 drop_partition_by_name_with_environment_context_result: + """ + Attributes: + - success + - o1 + - o2 + """ + + thrift_spec = ( + (0, TType.BOOL, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (MetaException, MetaException.thrift_spec), None, ), # 2 + ) + + def __init__(self, success=None, o1=None, o2=None,): + self.success = success + self.o1 = o1 + self.o2 = o2 + + 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.BOOL: + self.success = iprot.readBool(); + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = MetaException() + self.o2.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('drop_partition_by_name_with_environment_context_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) + 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() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + 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 drop_partitions_req_args: """ Attributes: - req @@ -12642,10 +13193,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype500, _size497) = iprot.readListBegin() - for _i501 in xrange(_size497): - _elem502 = iprot.readString(); - self.part_vals.append(_elem502) + (_etype535, _size532) = iprot.readListBegin() + for _i536 in xrange(_size532): + _elem537 = iprot.readString(); + self.part_vals.append(_elem537) iprot.readListEnd() else: iprot.skip(ftype) @@ -12670,8 +13221,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 iter503 in self.part_vals: - oprot.writeString(iter503) + for iter538 in self.part_vals: + oprot.writeString(iter538) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -12816,11 +13367,11 @@ def read(self, iprot): if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin() - for _i508 in xrange(_size504): - _key509 = iprot.readString(); - _val510 = iprot.readString(); - self.partitionSpecs[_key509] = _val510 + (_ktype540, _vtype541, _size539 ) = iprot.readMapBegin() + for _i543 in xrange(_size539): + _key544 = iprot.readString(); + _val545 = iprot.readString(); + self.partitionSpecs[_key544] = _val545 iprot.readMapEnd() else: iprot.skip(ftype) @@ -12857,9 +13408,9 @@ def write(self, oprot): if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter511,viter512 in self.partitionSpecs.items(): - oprot.writeString(kiter511) - oprot.writeString(viter512) + for kiter546,viter547 in self.partitionSpecs.items(): + oprot.writeString(kiter546) + oprot.writeString(viter547) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -13056,10 +13607,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype516, _size513) = iprot.readListBegin() - for _i517 in xrange(_size513): - _elem518 = iprot.readString(); - self.part_vals.append(_elem518) + (_etype551, _size548) = iprot.readListBegin() + for _i552 in xrange(_size548): + _elem553 = iprot.readString(); + self.part_vals.append(_elem553) iprot.readListEnd() else: iprot.skip(ftype) @@ -13071,10 +13622,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype522, _size519) = iprot.readListBegin() - for _i523 in xrange(_size519): - _elem524 = iprot.readString(); - self.group_names.append(_elem524) + (_etype557, _size554) = iprot.readListBegin() + for _i558 in xrange(_size554): + _elem559 = iprot.readString(); + self.group_names.append(_elem559) iprot.readListEnd() else: iprot.skip(ftype) @@ -13099,8 +13650,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 iter525 in self.part_vals: - oprot.writeString(iter525) + for iter560 in self.part_vals: + oprot.writeString(iter560) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -13110,8 +13661,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 iter526 in self.group_names: - oprot.writeString(iter526) + for iter561 in self.group_names: + oprot.writeString(iter561) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -13503,11 +14054,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype530, _size527) = iprot.readListBegin() - for _i531 in xrange(_size527): - _elem532 = Partition() - _elem532.read(iprot) - self.success.append(_elem532) + (_etype565, _size562) = iprot.readListBegin() + for _i566 in xrange(_size562): + _elem567 = Partition() + _elem567.read(iprot) + self.success.append(_elem567) iprot.readListEnd() else: iprot.skip(ftype) @@ -13536,8 +14087,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 iter533 in self.success: - iter533.write(oprot) + for iter568 in self.success: + iter568.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13624,10 +14175,10 @@ def read(self, iprot): elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype537, _size534) = iprot.readListBegin() - for _i538 in xrange(_size534): - _elem539 = iprot.readString(); - self.group_names.append(_elem539) + (_etype572, _size569) = iprot.readListBegin() + for _i573 in xrange(_size569): + _elem574 = iprot.readString(); + self.group_names.append(_elem574) iprot.readListEnd() else: iprot.skip(ftype) @@ -13660,8 +14211,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 iter540 in self.group_names: - oprot.writeString(iter540) + for iter575 in self.group_names: + oprot.writeString(iter575) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -13713,11 +14264,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype544, _size541) = iprot.readListBegin() - for _i545 in xrange(_size541): - _elem546 = Partition() - _elem546.read(iprot) - self.success.append(_elem546) + (_etype579, _size576) = iprot.readListBegin() + for _i580 in xrange(_size576): + _elem581 = Partition() + _elem581.read(iprot) + self.success.append(_elem581) iprot.readListEnd() else: iprot.skip(ftype) @@ -13746,8 +14297,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 iter547 in self.success: - iter547.write(oprot) + for iter582 in self.success: + iter582.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13888,10 +14439,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype551, _size548) = iprot.readListBegin() - for _i552 in xrange(_size548): - _elem553 = iprot.readString(); - self.success.append(_elem553) + (_etype586, _size583) = iprot.readListBegin() + for _i587 in xrange(_size583): + _elem588 = iprot.readString(); + self.success.append(_elem588) iprot.readListEnd() else: iprot.skip(ftype) @@ -13914,8 +14465,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 iter554 in self.success: - oprot.writeString(iter554) + for iter589 in self.success: + oprot.writeString(iter589) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -13985,10 +14536,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype558, _size555) = iprot.readListBegin() - for _i559 in xrange(_size555): - _elem560 = iprot.readString(); - self.part_vals.append(_elem560) + (_etype593, _size590) = iprot.readListBegin() + for _i594 in xrange(_size590): + _elem595 = iprot.readString(); + self.part_vals.append(_elem595) iprot.readListEnd() else: iprot.skip(ftype) @@ -14018,8 +14569,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 iter561 in self.part_vals: - oprot.writeString(iter561) + for iter596 in self.part_vals: + oprot.writeString(iter596) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -14075,11 +14626,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype565, _size562) = iprot.readListBegin() - for _i566 in xrange(_size562): - _elem567 = Partition() - _elem567.read(iprot) - self.success.append(_elem567) + (_etype600, _size597) = iprot.readListBegin() + for _i601 in xrange(_size597): + _elem602 = Partition() + _elem602.read(iprot) + self.success.append(_elem602) iprot.readListEnd() else: iprot.skip(ftype) @@ -14108,8 +14659,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 iter568 in self.success: - iter568.write(oprot) + for iter603 in self.success: + iter603.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14189,10 +14740,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype572, _size569) = iprot.readListBegin() - for _i573 in xrange(_size569): - _elem574 = iprot.readString(); - self.part_vals.append(_elem574) + (_etype607, _size604) = iprot.readListBegin() + for _i608 in xrange(_size604): + _elem609 = iprot.readString(); + self.part_vals.append(_elem609) iprot.readListEnd() else: iprot.skip(ftype) @@ -14209,10 +14760,10 @@ def read(self, iprot): elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype578, _size575) = iprot.readListBegin() - for _i579 in xrange(_size575): - _elem580 = iprot.readString(); - self.group_names.append(_elem580) + (_etype613, _size610) = iprot.readListBegin() + for _i614 in xrange(_size610): + _elem615 = iprot.readString(); + self.group_names.append(_elem615) iprot.readListEnd() else: iprot.skip(ftype) @@ -14237,8 +14788,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 iter581 in self.part_vals: - oprot.writeString(iter581) + for iter616 in self.part_vals: + oprot.writeString(iter616) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -14252,8 +14803,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 iter582 in self.group_names: - oprot.writeString(iter582) + for iter617 in self.group_names: + oprot.writeString(iter617) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -14305,11 +14856,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype586, _size583) = iprot.readListBegin() - for _i587 in xrange(_size583): - _elem588 = Partition() - _elem588.read(iprot) - self.success.append(_elem588) + (_etype621, _size618) = iprot.readListBegin() + for _i622 in xrange(_size618): + _elem623 = Partition() + _elem623.read(iprot) + self.success.append(_elem623) iprot.readListEnd() else: iprot.skip(ftype) @@ -14338,8 +14889,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 iter589 in self.success: - iter589.write(oprot) + for iter624 in self.success: + iter624.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14413,10 +14964,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype593, _size590) = iprot.readListBegin() - for _i594 in xrange(_size590): - _elem595 = iprot.readString(); - self.part_vals.append(_elem595) + (_etype628, _size625) = iprot.readListBegin() + for _i629 in xrange(_size625): + _elem630 = iprot.readString(); + self.part_vals.append(_elem630) iprot.readListEnd() else: iprot.skip(ftype) @@ -14446,8 +14997,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 iter596 in self.part_vals: - oprot.writeString(iter596) + for iter631 in self.part_vals: + oprot.writeString(iter631) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -14503,10 +15054,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype600, _size597) = iprot.readListBegin() - for _i601 in xrange(_size597): - _elem602 = iprot.readString(); - self.success.append(_elem602) + (_etype635, _size632) = iprot.readListBegin() + for _i636 in xrange(_size632): + _elem637 = iprot.readString(); + self.success.append(_elem637) iprot.readListEnd() else: iprot.skip(ftype) @@ -14535,8 +15086,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 iter603 in self.success: - oprot.writeString(iter603) + for iter638 in self.success: + oprot.writeString(iter638) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14692,11 +15243,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype607, _size604) = iprot.readListBegin() - for _i608 in xrange(_size604): - _elem609 = Partition() - _elem609.read(iprot) - self.success.append(_elem609) + (_etype642, _size639) = iprot.readListBegin() + for _i643 in xrange(_size639): + _elem644 = Partition() + _elem644.read(iprot) + self.success.append(_elem644) iprot.readListEnd() else: iprot.skip(ftype) @@ -14725,8 +15276,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 iter610 in self.success: - iter610.write(oprot) + for iter645 in self.success: + iter645.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14944,10 +15495,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype614, _size611) = iprot.readListBegin() - for _i615 in xrange(_size611): - _elem616 = iprot.readString(); - self.names.append(_elem616) + (_etype649, _size646) = iprot.readListBegin() + for _i650 in xrange(_size646): + _elem651 = iprot.readString(); + self.names.append(_elem651) iprot.readListEnd() else: iprot.skip(ftype) @@ -14972,8 +15523,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 iter617 in self.names: - oprot.writeString(iter617) + for iter652 in self.names: + oprot.writeString(iter652) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -15025,11 +15576,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype621, _size618) = iprot.readListBegin() - for _i622 in xrange(_size618): - _elem623 = Partition() - _elem623.read(iprot) - self.success.append(_elem623) + (_etype656, _size653) = iprot.readListBegin() + for _i657 in xrange(_size653): + _elem658 = Partition() + _elem658.read(iprot) + self.success.append(_elem658) iprot.readListEnd() else: iprot.skip(ftype) @@ -15058,8 +15609,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 iter624 in self.success: - iter624.write(oprot) + for iter659 in self.success: + iter659.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15289,11 +15840,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype628, _size625) = iprot.readListBegin() - for _i629 in xrange(_size625): - _elem630 = Partition() - _elem630.read(iprot) - self.new_parts.append(_elem630) + (_etype663, _size660) = iprot.readListBegin() + for _i664 in xrange(_size660): + _elem665 = Partition() + _elem665.read(iprot) + self.new_parts.append(_elem665) iprot.readListEnd() else: iprot.skip(ftype) @@ -15318,8 +15869,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 iter631 in self.new_parts: - iter631.write(oprot) + for iter666 in self.new_parts: + iter666.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -15631,10 +16182,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype635, _size632) = iprot.readListBegin() - for _i636 in xrange(_size632): - _elem637 = iprot.readString(); - self.part_vals.append(_elem637) + (_etype670, _size667) = iprot.readListBegin() + for _i671 in xrange(_size667): + _elem672 = iprot.readString(); + self.part_vals.append(_elem672) iprot.readListEnd() else: iprot.skip(ftype) @@ -15665,8 +16216,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 iter638 in self.part_vals: - oprot.writeString(iter638) + for iter673 in self.part_vals: + oprot.writeString(iter673) oprot.writeListEnd() oprot.writeFieldEnd() if self.new_part is not None: @@ -15794,10 +16345,10 @@ def read(self, iprot): if fid == 1: if ftype == TType.LIST: self.part_vals = [] - (_etype642, _size639) = iprot.readListBegin() - for _i643 in xrange(_size639): - _elem644 = iprot.readString(); - self.part_vals.append(_elem644) + (_etype677, _size674) = iprot.readListBegin() + for _i678 in xrange(_size674): + _elem679 = iprot.readString(); + self.part_vals.append(_elem679) iprot.readListEnd() else: iprot.skip(ftype) @@ -15819,8 +16370,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 iter645 in self.part_vals: - oprot.writeString(iter645) + for iter680 in self.part_vals: + oprot.writeString(iter680) oprot.writeListEnd() oprot.writeFieldEnd() if self.throw_exception is not None: @@ -16149,10 +16700,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype649, _size646) = iprot.readListBegin() - for _i650 in xrange(_size646): - _elem651 = iprot.readString(); - self.success.append(_elem651) + (_etype684, _size681) = iprot.readListBegin() + for _i685 in xrange(_size681): + _elem686 = iprot.readString(); + self.success.append(_elem686) iprot.readListEnd() else: iprot.skip(ftype) @@ -16175,8 +16726,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 iter652 in self.success: - oprot.writeString(iter652) + for iter687 in self.success: + oprot.writeString(iter687) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -16289,11 +16840,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype654, _vtype655, _size653 ) = iprot.readMapBegin() - for _i657 in xrange(_size653): - _key658 = iprot.readString(); - _val659 = iprot.readString(); - self.success[_key658] = _val659 + (_ktype689, _vtype690, _size688 ) = iprot.readMapBegin() + for _i692 in xrange(_size688): + _key693 = iprot.readString(); + _val694 = iprot.readString(); + self.success[_key693] = _val694 iprot.readMapEnd() else: iprot.skip(ftype) @@ -16316,9 +16867,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 kiter660,viter661 in self.success.items(): - oprot.writeString(kiter660) - oprot.writeString(viter661) + for kiter695,viter696 in self.success.items(): + oprot.writeString(kiter695) + oprot.writeString(viter696) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -16388,11 +16939,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype663, _vtype664, _size662 ) = iprot.readMapBegin() - for _i666 in xrange(_size662): - _key667 = iprot.readString(); - _val668 = iprot.readString(); - self.part_vals[_key667] = _val668 + (_ktype698, _vtype699, _size697 ) = iprot.readMapBegin() + for _i701 in xrange(_size697): + _key702 = iprot.readString(); + _val703 = iprot.readString(); + self.part_vals[_key702] = _val703 iprot.readMapEnd() else: iprot.skip(ftype) @@ -16422,9 +16973,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 kiter669,viter670 in self.part_vals.items(): - oprot.writeString(kiter669) - oprot.writeString(viter670) + for kiter704,viter705 in self.part_vals.items(): + oprot.writeString(kiter704) + oprot.writeString(viter705) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -16620,11 +17171,11 @@ def read(self, iprot): elif fid == 3: if ftype == TType.MAP: self.part_vals = {} - (_ktype672, _vtype673, _size671 ) = iprot.readMapBegin() - for _i675 in xrange(_size671): - _key676 = iprot.readString(); - _val677 = iprot.readString(); - self.part_vals[_key676] = _val677 + (_ktype707, _vtype708, _size706 ) = iprot.readMapBegin() + for _i710 in xrange(_size706): + _key711 = iprot.readString(); + _val712 = iprot.readString(); + self.part_vals[_key711] = _val712 iprot.readMapEnd() else: iprot.skip(ftype) @@ -16654,9 +17205,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 kiter678,viter679 in self.part_vals.items(): - oprot.writeString(kiter678) - oprot.writeString(viter679) + for kiter713,viter714 in self.part_vals.items(): + oprot.writeString(kiter713) + oprot.writeString(viter714) oprot.writeMapEnd() oprot.writeFieldEnd() if self.eventType is not None: @@ -17628,11 +18179,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype683, _size680) = iprot.readListBegin() - for _i684 in xrange(_size680): - _elem685 = Index() - _elem685.read(iprot) - self.success.append(_elem685) + (_etype718, _size715) = iprot.readListBegin() + for _i719 in xrange(_size715): + _elem720 = Index() + _elem720.read(iprot) + self.success.append(_elem720) iprot.readListEnd() else: iprot.skip(ftype) @@ -17661,8 +18212,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 iter721 in self.success: + iter721.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17803,10 +18354,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype690, _size687) = iprot.readListBegin() - for _i691 in xrange(_size687): - _elem692 = iprot.readString(); - self.success.append(_elem692) + (_etype725, _size722) = iprot.readListBegin() + for _i726 in xrange(_size722): + _elem727 = iprot.readString(); + self.success.append(_elem727) iprot.readListEnd() else: iprot.skip(ftype) @@ -17829,8 +18380,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 iter693 in self.success: - oprot.writeString(iter693) + for iter728 in self.success: + oprot.writeString(iter728) oprot.writeListEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -19865,10 +20416,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype697, _size694) = iprot.readListBegin() - for _i698 in xrange(_size694): - _elem699 = iprot.readString(); - self.success.append(_elem699) + (_etype732, _size729) = iprot.readListBegin() + for _i733 in xrange(_size729): + _elem734 = iprot.readString(); + self.success.append(_elem734) iprot.readListEnd() else: iprot.skip(ftype) @@ -19891,8 +20442,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 iter700 in self.success: - oprot.writeString(iter700) + for iter735 in self.success: + oprot.writeString(iter735) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20410,10 +20961,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype704, _size701) = iprot.readListBegin() - for _i705 in xrange(_size701): - _elem706 = iprot.readString(); - self.success.append(_elem706) + (_etype739, _size736) = iprot.readListBegin() + for _i740 in xrange(_size736): + _elem741 = iprot.readString(); + self.success.append(_elem741) iprot.readListEnd() else: iprot.skip(ftype) @@ -20436,8 +20987,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 iter707 in self.success: - oprot.writeString(iter707) + for iter742 in self.success: + oprot.writeString(iter742) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20910,11 +21461,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype711, _size708) = iprot.readListBegin() - for _i712 in xrange(_size708): - _elem713 = Role() - _elem713.read(iprot) - self.success.append(_elem713) + (_etype746, _size743) = iprot.readListBegin() + for _i747 in xrange(_size743): + _elem748 = Role() + _elem748.read(iprot) + self.success.append(_elem748) iprot.readListEnd() else: iprot.skip(ftype) @@ -20937,8 +21488,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 iter714 in self.success: - iter714.write(oprot) + for iter749 in self.success: + iter749.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21274,10 +21825,10 @@ def read(self, iprot): elif fid == 3: if ftype == TType.LIST: self.group_names = [] - (_etype718, _size715) = iprot.readListBegin() - for _i719 in xrange(_size715): - _elem720 = iprot.readString(); - self.group_names.append(_elem720) + (_etype753, _size750) = iprot.readListBegin() + for _i754 in xrange(_size750): + _elem755 = iprot.readString(); + self.group_names.append(_elem755) iprot.readListEnd() else: iprot.skip(ftype) @@ -21302,8 +21853,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 iter721 in self.group_names: - oprot.writeString(iter721) + for iter756 in self.group_names: + oprot.writeString(iter756) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -21510,11 +22061,11 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype725, _size722) = iprot.readListBegin() - for _i726 in xrange(_size722): - _elem727 = HiveObjectPrivilege() - _elem727.read(iprot) - self.success.append(_elem727) + (_etype760, _size757) = iprot.readListBegin() + for _i761 in xrange(_size757): + _elem762 = HiveObjectPrivilege() + _elem762.read(iprot) + self.success.append(_elem762) iprot.readListEnd() else: iprot.skip(ftype) @@ -21537,8 +22088,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 iter763 in self.success: + iter763.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -21863,10 +22414,10 @@ def read(self, iprot): elif fid == 2: if ftype == TType.LIST: self.group_names = [] - (_etype732, _size729) = iprot.readListBegin() - for _i733 in xrange(_size729): - _elem734 = iprot.readString(); - self.group_names.append(_elem734) + (_etype767, _size764) = iprot.readListBegin() + for _i768 in xrange(_size764): + _elem769 = iprot.readString(); + self.group_names.append(_elem769) iprot.readListEnd() else: iprot.skip(ftype) @@ -21887,8 +22438,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 iter735 in self.group_names: - oprot.writeString(iter735) + for iter770 in self.group_names: + oprot.writeString(iter770) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -21937,10 +22488,10 @@ def read(self, iprot): if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype739, _size736) = iprot.readListBegin() - for _i740 in xrange(_size736): - _elem741 = iprot.readString(); - self.success.append(_elem741) + (_etype774, _size771) = iprot.readListBegin() + for _i775 in xrange(_size771): + _elem776 = iprot.readString(); + self.success.append(_elem776) iprot.readListEnd() else: iprot.skip(ftype) @@ -21963,8 +22514,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 iter742 in self.success: - oprot.writeString(iter742) + for iter777 in self.success: + oprot.writeString(iter777) 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 56c23e6..45fcc97 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -544,6 +544,40 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'append_partition_by_name_with_environment_context failed: unknown result') end + def add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData) + send_add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData) + return recv_add_drop_partitions() + end + + def send_add_drop_partitions(db_name, tbl_name, add_parts, drop_part_vals, deleteData) + send_message('add_drop_partitions', Add_drop_partitions_args, :db_name => db_name, :tbl_name => tbl_name, :add_parts => add_parts, :drop_part_vals => drop_part_vals, :deleteData => deleteData) + end + + def recv_add_drop_partitions() + result = receive_message(Add_drop_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, 'add_drop_partitions failed: unknown result') + end + + def drop_partitions(db_name, tbl_name, part_vals, deleteData) + send_drop_partitions(db_name, tbl_name, part_vals, deleteData) + return recv_drop_partitions() + end + + def send_drop_partitions(db_name, tbl_name, part_vals, deleteData) + send_message('drop_partitions', Drop_partitions_args, :db_name => db_name, :tbl_name => tbl_name, :part_vals => part_vals, :deleteData => deleteData) + end + + def recv_drop_partitions() + result = receive_message(Drop_partitions_result) + return result.success unless result.success.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'drop_partitions failed: unknown result') + end + def drop_partition(db_name, tbl_name, part_vals, deleteData) send_drop_partition(db_name, tbl_name, part_vals, deleteData) return recv_drop_partition() @@ -2246,6 +2280,30 @@ module ThriftHiveMetastore write_result(result, oprot, 'append_partition_by_name_with_environment_context', seqid) end + def process_add_drop_partitions(seqid, iprot, oprot) + args = read_args(iprot, Add_drop_partitions_args) + result = Add_drop_partitions_result.new() + begin + result.success = @handler.add_drop_partitions(args.db_name, args.tbl_name, args.add_parts, args.drop_part_vals, args.deleteData) + rescue ::InvalidObjectException => o1 + result.o1 = o1 + rescue ::AlreadyExistsException => o2 + result.o2 = o2 + rescue ::NoSuchObjectException => o3 + result.o3 = o3 + rescue ::MetaException => o4 + result.o4 = o4 + end + write_result(result, oprot, 'add_drop_partitions', seqid) + end + + def process_drop_partitions(seqid, iprot, oprot) + args = read_args(iprot, Drop_partitions_args) + result = Drop_partitions_result.new() + result.success = @handler.drop_partitions(args.db_name, args.tbl_name, args.part_vals, args.deleteData) + write_result(result, oprot, 'drop_partitions', seqid) + end + def process_drop_partition(seqid, iprot, oprot) args = read_args(iprot, Drop_partition_args) result = Drop_partition_result.new() @@ -4391,6 +4449,92 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Add_drop_partitions_args + include ::Thrift::Struct, ::Thrift::Struct_Union + DB_NAME = 1 + TBL_NAME = 2 + ADD_PARTS = 3 + DROP_PART_VALS = 4 + DELETEDATA = 5 + + FIELDS = { + DB_NAME => {:type => ::Thrift::Types::STRING, :name => 'db_name'}, + TBL_NAME => {:type => ::Thrift::Types::STRING, :name => 'tbl_name'}, + ADD_PARTS => {:type => ::Thrift::Types::LIST, :name => 'add_parts', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Partition}}, + DROP_PART_VALS => {:type => ::Thrift::Types::LIST, :name => 'drop_part_vals', :element => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRING}}}, + DELETEDATA => {:type => ::Thrift::Types::BOOL, :name => 'deleteData'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Add_drop_partitions_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + O4 = 4 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::InvalidObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::AlreadyExistsException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::NoSuchObjectException}, + O4 => {:type => ::Thrift::Types::STRUCT, :name => 'o4', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_partitions_args + include ::Thrift::Struct, ::Thrift::Struct_Union + DB_NAME = 1 + TBL_NAME = 2 + PART_VALS = 3 + DELETEDATA = 4 + + FIELDS = { + DB_NAME => {:type => ::Thrift::Types::STRING, :name => 'db_name'}, + TBL_NAME => {:type => ::Thrift::Types::STRING, :name => 'tbl_name'}, + PART_VALS => {:type => ::Thrift::Types::LIST, :name => 'part_vals', :element => {:type => ::Thrift::Types::LIST, :element => {:type => ::Thrift::Types::STRING}}}, + DELETEDATA => {:type => ::Thrift::Types::BOOL, :name => 'deleteData'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_partitions_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Drop_partition_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 a6afd8c..f07b185 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -188,6 +188,7 @@ import com.google.common.base.Splitter; import com.google.common.collect.Lists; + /** * TODO:pc remove application logic to a separate interface. */ @@ -2096,6 +2097,203 @@ private void fireMetaStoreAddPartitionEvent(final Table tbl, } } + private void fireMetaStoreDropPartitionEvent(final Table tbl, + final List parts, final EnvironmentContext envContext, boolean success, boolean deleteData) + throws MetaException { + if (tbl != null && parts != null && !parts.isEmpty()) { + for (Partition part : parts) { + for (MetaStoreEventListener listener : listeners) { + DropPartitionEvent dropPartitionEvent = + new DropPartitionEvent(tbl, part, success, deleteData, this); + dropPartitionEvent.setEnvironmentContext(envContext); + listener.onDropPartition(dropPartitionEvent); + } + } + } + } + + private boolean add_drop_partitions_core( + final RawStore ms, String db_name, String tbl_name, final List addParts, + final List> dropParts, boolean deleteData, boolean ifNotExists, + final EnvironmentContext envContext) throws MetaException, InvalidObjectException, NoSuchObjectException, + AlreadyExistsException, IOException, InvalidInputException, TException { + logInfo("add_drop_partitions : db=" + db_name + " tbl=" + tbl_name); + boolean success = false; + Table tbl = null; + List deletedPartitions = new ArrayList(); + // Ensures that the list doesn't have dups, and keeps track of directories we have created. + Map addedPartitions = new HashMap(); + List existingParts = new ArrayList(); + List result = new ArrayList(); + try { + ms.openTransaction(); + tbl = get_table(db_name, tbl_name); + if (tbl == null) { + throw new InvalidObjectException("Unable to add partitions because " + + "database or table " + db_name + "." + tbl_name + " does not exist"); + } + // Drop the parts first + deletedPartitions = drop_partitions_core_notxn(ms, tbl, dropParts, deleteData); + + // Now add the parts + result = add_partitions_core_notxn(ms, tbl, addParts, ifNotExists, addedPartitions, existingParts); + + if (!result.isEmpty() && !ms.addPartitions(db_name, tbl_name, result)) { + throw new MetaException("Unable to add partitions"); + } + success = ms.commitTransaction(); + } finally { + if (!success) { + ms.rollbackTransaction(); + // Clean up the result of adding partitions + for (Entry e : addedPartitions.entrySet()) { + if (e.getValue()) { + wh.deleteDir(new Path(e.getKey().partition.getSd().getLocation()), true); + // we just created this directory - it's not a case of pre-creation, so we nuke + } + } + fireMetaStoreAddPartitionEvent(tbl, addParts, null, false); + } else if (deleteData) { + for(Partition partition: deletedPartitions) { + delete_data(partition); + } + } else { + fireMetaStoreAddPartitionEvent(tbl, result, null, true); + if (!existingParts.isEmpty()) { + // The request has succeeded but we failed to add these partitions. + fireMetaStoreAddPartitionEvent(tbl, existingParts, null, false); + } + } + if (!deletedPartitions.isEmpty()) { + fireMetaStoreDropPartitionEvent(tbl, deletedPartitions, envContext, success, deleteData); + } + } + return success; + } + + private List add_partitions_core_notxn( + RawStore ms, Table tbl, List parts, boolean ifNotExists, + Map addedPartitions, List existingParts) + throws MetaException, InvalidObjectException, AlreadyExistsException, TException { + logInfo("add_partitions"); + String dbName = tbl.getDbName(); + String tblName = tbl.getTableName(); + List result = new ArrayList(); + if (!parts.isEmpty()) { + firePreEvent(new PreAddPartitionEvent(tbl, parts, this)); + } + for (Partition part : parts) { + if (!part.getTableName().equals(tblName) || !part.getDbName().equals(dbName)) { + throw new MetaException("Partition does not belong to target table " + + dbName + "." + tblName + ": " + part); + } + boolean shouldAdd = startAddPartition(ms, part, ifNotExists); + if (!shouldAdd) { + existingParts.add(part); + LOG.info("Not adding partition " + part + " as it already exists"); + continue; + } + boolean madeDir = createLocationForAddedPartition(tbl, part); + if (addedPartitions.put(new PartValEqWrapper(part), madeDir) != null) { + // Technically, for ifNotExists case, we could insert one and discard the other + // because the first one now "exists", but it seems better to report the problem + // upstream as such a command doesn't make sense. + throw new MetaException("Duplicate partitions in the list: " + part); + } + initializeAddedPartition(tbl, part, madeDir); + result.add(part); + } + return result; + } + + private List drop_partitions_core_notxn( + RawStore ms, Table tbl, List> part_values, final boolean deleteData) + throws MetaException, NoSuchObjectException, InvalidObjectException, InvalidInputException { + List deletedPartitions = new ArrayList(); + Partition part = null; + String dbName = tbl.getDbName(); + String tblName = tbl.getTableName(); + + for (List part_vals : part_values) { + part = ms.getPartition(dbName, tblName, part_vals); + firePreEvent(new PreDropPartitionEvent(tbl, part, deleteData, this)); + if (part == null) { + throw new NoSuchObjectException("Partition doesn't exist. " + + part_vals); + } + if (!ms.dropPartition(dbName, tblName, part_vals)) { + throw new MetaException("Unable to drop partition"); + } + deletedPartitions.add(part); + } + return deletedPartitions; + } + + private boolean drop_partitions_core( + RawStore ms, String db_name, String tbl_name, List> part_values, + final boolean deleteData, final EnvironmentContext envContext) + throws MetaException, NoSuchObjectException, IOException, InvalidObjectException, InvalidInputException { + boolean success = false; + List deletedPartitions = null; + Table tbl = null; + try { + ms.openTransaction(); + tbl = get_table(db_name, tbl_name); + deletedPartitions = drop_partitions_core_notxn(ms, tbl, part_values, deleteData); + success = ms.commitTransaction(); + } finally { + if (!success) { + ms.rollbackTransaction(); + } else if (deleteData) { + for (Partition partition : deletedPartitions) { + delete_data(partition); + } + } + if (deletedPartitions != null) { + fireMetaStoreDropPartitionEvent(tbl, deletedPartitions, envContext, success, deleteData); + } + } + return success; + } + + private void delete_data(Partition part) + throws NoSuchObjectException, MetaException, IOException{ + boolean isArchived = false; + Path archiveParentDir = null; + Path partPath = null; + Table tbl = get_table(part.getDbName(), part.getTableName()); + + isArchived = MetaStoreUtils.isArchived(part); + if (isArchived) { + archiveParentDir = MetaStoreUtils.getOriginalLocation(part); + if (!wh.isWritable(archiveParentDir.getParent())) { + throw new MetaException("Table partition not deleted since " + + archiveParentDir.getParent() + " is not writable by " + + hiveConf.getUser()); + } + } + if ((part.getSd() != null) && (part.getSd().getLocation() != null)) { + partPath = new Path(part.getSd().getLocation()); + if (!wh.isWritable(partPath.getParent())) { + throw new MetaException("Table partition not deleted since " + + partPath.getParent() + " is not writable by " + + hiveConf.getUser()); + } + } + if (tbl != null && !isExternal(tbl)) { + // Archived partitions have har:/to_har_file as their location. + // The original directory was saved in params + if (isArchived) { + assert(archiveParentDir != null); + wh.deleteDir(archiveParentDir, true); + } else { + assert(partPath != null); + wh.deleteDir(partPath, true); + } + // ok even if the data is not deleted + } + } + @Override public Partition add_partition(final Partition part) throws InvalidObjectException, AlreadyExistsException, MetaException { @@ -2456,6 +2654,67 @@ public boolean drop_partition_with_environment_context(final String db_name, } + public boolean drop_partitions( + final String db_name, final String tbl_name, final List> part_values, final boolean deleteData) + throws NoSuchObjectException, MetaException, TException { + startFunction("drop_partitions : db=" + db_name + " tbl=" + tbl_name); + for(List part_vals: part_values) { + LOG.info("Partition values:" + part_vals); + } + boolean ret = false; + Exception ex = null; + try { + ret = drop_partitions_core(getMS(), db_name, tbl_name, part_values, deleteData, null); + } catch (IOException e) { + ex = e; + throw new MetaException(e.getMessage()); + } catch (Exception e) { + ex = e; + rethrowException(e); + } finally { + endFunction("drop_partitions", ret, ex, tbl_name); + } + return ret; + + } + + public boolean add_drop_partitions(final String db_name, + final String tbl_name, final List addParts, + final List> dropParts, final boolean deleteData) + throws NoSuchObjectException, MetaException, TException { + startFunction("add_drop_partitions : db=" + db_name + " tbl=" + tbl_name); + if(addParts.size() == 0 && dropParts.size() == 0) { + return true; + } + for(List part_vals: dropParts) { + LOG.info("Drop Partition values:" + part_vals); + } + for(Partition part: addParts) { + LOG.info("Add Partition values:" + part); + } + + boolean ret = false; + Exception ex = null; + try { + ret = add_drop_partitions_core(getMS(), db_name, tbl_name, addParts, dropParts, deleteData, false, null); + } catch (Exception e) { + ex = e; + if (e instanceof MetaException) { + throw (MetaException) e; + } else if (e instanceof InvalidObjectException) { + throw (InvalidObjectException) e; + } else if (e instanceof AlreadyExistsException) { + throw (AlreadyExistsException) e; + } else { + throw newMetaException(e); + } + } finally { + endFunction("drop_partitions", ret, ex, tbl_name); + } + return ret; + + } + @Override public Partition get_partition(final String db_name, final String tbl_name, final List part_vals) throws MetaException, NoSuchObjectException { 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 664dccd..b8b0828 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java @@ -626,6 +626,43 @@ public void dropDatabase(String name, boolean deleteData, boolean ignoreUnknownD client.drop_database(name, deleteData, cascade); } + /** + * + * @param db_name + * @param tbl_name + * @param delete_part_vals + * @param deleteData + * @return + * @throws NoSuchObjectException + * @throws MetaException + * @throws TException + */ + public boolean dropPartitions(String db_name, String tbl_name, + List> delete_part_vals, boolean deleteData) + throws NoSuchObjectException, MetaException, TException { + return client.drop_partitions(db_name, tbl_name, delete_part_vals, deleteData); + } + + /** + * + * @param db_name + * @param tbl_name + * @param add_parts + * @param delete_part_vals + * @param deleteData + * @return + * @throws InvalidObjectException + * @throws AlreadyExistsException + * @throws NoSuchObjectException + * @throws MetaException + * @throws TException + */ + public boolean addDropPartitions(String db_name, String tbl_name, + List add_parts, List> delete_part_vals, boolean deleteData) + throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, + MetaException, TException { + return client.add_drop_partitions(db_name, tbl_name, add_parts, delete_part_vals, deleteData); + } /** * @param tbl_name 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 0c2209b..ad69cad 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java @@ -630,6 +630,39 @@ public boolean dropPartition(String db_name, String tbl_name, String name, boolean deleteData) throws NoSuchObjectException, MetaException, TException; /** + * + * @param db_name + * @param tbl_name + * @param list_part_vals + * @param deleteData + * @return + * @throws NoSuchObjectException + * @throws MetaException + * @throws TException + */ + public boolean dropPartitions(String db_name, String tbl_name, + List> list_part_vals, boolean deleteData) throws NoSuchObjectException, + MetaException, TException; + + /** + * + * @param db_name + * @param tbl_name + * @param addParts + * @param list_part_vals + * @param deleteData + * @return + * @throws InvalidObjectException + * @throws AlreadyExistsException + * @throws NoSuchObjectException + * @throws MetaException + * @throws TException + */ + public boolean addDropPartitions(String db_name, String tbl_name, + List addParts, List> list_part_vals, boolean deleteData) + throws InvalidObjectException, AlreadyExistsException, NoSuchObjectException, + MetaException, TException; + /** * updates a partition to new partition * * @param dbName