Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1561947&r1=1561946&r2=1561947&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Tue Jan 28 05:48:03 2014 @@ -43,6 +43,7 @@ class ThriftHiveMetastoreIf : virtual pu virtual void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) = 0; virtual int32_t add_partitions(const std::vector<Partition> & new_parts) = 0; virtual void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) = 0; + virtual void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) = 0; virtual void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & 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; @@ -212,6 +213,9 @@ class ThriftHiveMetastoreNull : virtual void append_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) { return; } + void add_partitions_req(AddPartitionsResult& /* _return */, const AddPartitionsRequest& /* request */) { + return; + } void append_partition_with_environment_context(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const EnvironmentContext& /* environment_context */) { return; } @@ -4068,6 +4072,144 @@ class ThriftHiveMetastore_append_partiti }; +typedef struct _ThriftHiveMetastore_add_partitions_req_args__isset { + _ThriftHiveMetastore_add_partitions_req_args__isset() : request(false) {} + bool request; +} _ThriftHiveMetastore_add_partitions_req_args__isset; + +class ThriftHiveMetastore_add_partitions_req_args { + public: + + ThriftHiveMetastore_add_partitions_req_args() { + } + + virtual ~ThriftHiveMetastore_add_partitions_req_args() throw() {} + + AddPartitionsRequest request; + + _ThriftHiveMetastore_add_partitions_req_args__isset __isset; + + void __set_request(const AddPartitionsRequest& val) { + request = val; + } + + bool operator == (const ThriftHiveMetastore_add_partitions_req_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_add_partitions_req_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_req_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_add_partitions_req_pargs { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_req_pargs() throw() {} + + const AddPartitionsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_req_result__isset { + _ThriftHiveMetastore_add_partitions_req_result__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success; + bool o1; + bool o2; + bool o3; +} _ThriftHiveMetastore_add_partitions_req_result__isset; + +class ThriftHiveMetastore_add_partitions_req_result { + public: + + ThriftHiveMetastore_add_partitions_req_result() { + } + + virtual ~ThriftHiveMetastore_add_partitions_req_result() throw() {} + + AddPartitionsResult success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_req_result__isset __isset; + + void __set_success(const AddPartitionsResult& val) { + success = val; + } + + void __set_o1(const InvalidObjectException& val) { + o1 = val; + } + + void __set_o2(const AlreadyExistsException& val) { + o2 = val; + } + + void __set_o3(const MetaException& val) { + o3 = val; + } + + bool operator == (const ThriftHiveMetastore_add_partitions_req_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; + return true; + } + bool operator != (const ThriftHiveMetastore_add_partitions_req_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_add_partitions_req_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_add_partitions_req_presult__isset { + _ThriftHiveMetastore_add_partitions_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {} + bool success; + bool o1; + bool o2; + bool o3; +} _ThriftHiveMetastore_add_partitions_req_presult__isset; + +class ThriftHiveMetastore_add_partitions_req_presult { + public: + + + virtual ~ThriftHiveMetastore_add_partitions_req_presult() throw() {} + + AddPartitionsResult* success; + InvalidObjectException o1; + AlreadyExistsException o2; + MetaException o3; + + _ThriftHiveMetastore_add_partitions_req_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_args__isset { _ThriftHiveMetastore_append_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_vals(false), environment_context(false) {} bool db_name; @@ -12322,6 +12464,9 @@ class ThriftHiveMetastoreClient : virtua void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals); void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals); void recv_append_partition(Partition& _return); + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request); + void send_add_partitions_req(const AddPartitionsRequest& request); + void recv_add_partitions_req(AddPartitionsResult& _return); void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context); void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context); void recv_append_partition_with_environment_context(Partition& _return); @@ -12527,6 +12672,7 @@ class ThriftHiveMetastoreProcessor : pub void process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_add_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 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); @@ -12614,6 +12760,7 @@ class ThriftHiveMetastoreProcessor : pub processMap_["add_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context; processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions; processMap_["append_partition"] = &ThriftHiveMetastoreProcessor::process_append_partition; + processMap_["add_partitions_req"] = &ThriftHiveMetastoreProcessor::process_add_partitions_req; 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; @@ -12961,6 +13108,16 @@ class ThriftHiveMetastoreMultiface : vir return; } + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->add_partitions_req(_return, request); + } + ifaces_[i]->add_partitions_req(_return, request); + return; + } + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context) { size_t sz = ifaces_.size(); size_t i = 0;
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1561947&r1=1561946&r2=1561947&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Tue Jan 28 05:48:03 2014 @@ -157,6 +157,11 @@ class ThriftHiveMetastoreHandler : virtu printf("append_partition\n"); } + void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) { + // Your implementation goes here + printf("add_partitions_req\n"); + } + void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context) { // Your implementation goes here printf("append_partition_with_environment_context\n"); Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1561947&r1=1561946&r2=1561947&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Tue Jan 28 05:48:03 2014 @@ -3719,8 +3719,8 @@ void swap(EnvironmentContext &a, Environ swap(a.__isset, b.__isset); } -const char* PartitionsByExprResult::ascii_fingerprint = "1B91CF0D2FC339DC29ABBD79CC9700E4"; -const uint8_t PartitionsByExprResult::binary_fingerprint[16] = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4}; +const char* PartitionsByExprResult::ascii_fingerprint = "40B789CC91B508FE36600A14E3F80425"; +const uint8_t PartitionsByExprResult::binary_fingerprint[16] = {0x40,0xB7,0x89,0xCC,0x91,0xB5,0x08,0xFE,0x36,0x60,0x0A,0x14,0xE3,0xF8,0x04,0x25}; uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* iprot) { @@ -3745,20 +3745,19 @@ uint32_t PartitionsByExprResult::read(:: switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_SET) { + if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); uint32_t _size201; ::apache::thrift::protocol::TType _etype204; - xfer += iprot->readSetBegin(_etype204, _size201); + xfer += iprot->readListBegin(_etype204, _size201); + this->partitions.resize(_size201); uint32_t _i205; for (_i205 = 0; _i205 < _size201; ++_i205) { - Partition _elem206; - xfer += _elem206.read(iprot); - this->partitions.insert(_elem206); + xfer += this->partitions[_i205].read(iprot); } - xfer += iprot->readSetEnd(); + xfer += iprot->readListEnd(); } isset_partitions = true; } else { @@ -3793,15 +3792,15 @@ uint32_t PartitionsByExprResult::write(: uint32_t xfer = 0; xfer += oprot->writeStructBegin("PartitionsByExprResult"); - xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_SET, 1); + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { - xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); - std::set<Partition> ::const_iterator _iter207; - for (_iter207 = this->partitions.begin(); _iter207 != this->partitions.end(); ++_iter207) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); + std::vector<Partition> ::const_iterator _iter206; + for (_iter206 = this->partitions.begin(); _iter206 != this->partitions.end(); ++_iter206) { - xfer += (*_iter207).write(oprot); + xfer += (*_iter206).write(oprot); } - xfer += oprot->writeSetEnd(); + xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); @@ -3945,6 +3944,236 @@ void swap(PartitionsByExprRequest &a, Pa swap(a.__isset, b.__isset); } +const char* AddPartitionsResult::ascii_fingerprint = "5A689D0823E7BFBB60C799BA60065C31"; +const uint8_t AddPartitionsResult::binary_fingerprint[16] = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31}; + +uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitions.clear(); + uint32_t _size207; + ::apache::thrift::protocol::TType _etype210; + xfer += iprot->readListBegin(_etype210, _size207); + this->partitions.resize(_size207); + uint32_t _i211; + for (_i211 = 0; _i211 < _size207; ++_i211) + { + xfer += this->partitions[_i211].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("AddPartitionsResult"); + + if (this->__isset.partitions) { + xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); + std::vector<Partition> ::const_iterator _iter212; + for (_iter212 = this->partitions.begin(); _iter212 != this->partitions.end(); ++_iter212) + { + xfer += (*_iter212).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPartitionsResult &a, AddPartitionsResult &b) { + using ::std::swap; + swap(a.partitions, b.partitions); + swap(a.__isset, b.__isset); +} + +const char* AddPartitionsRequest::ascii_fingerprint = "94F938D035892CF6873DEDB99358F069"; +const uint8_t AddPartitionsRequest::binary_fingerprint[16] = {0x94,0xF9,0x38,0xD0,0x35,0x89,0x2C,0xF6,0x87,0x3D,0xED,0xB9,0x93,0x58,0xF0,0x69}; + +uint32_t AddPartitionsRequest::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; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_parts = false; + bool isset_ifNotExists = false; + + 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->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->parts.clear(); + uint32_t _size213; + ::apache::thrift::protocol::TType _etype216; + xfer += iprot->readListBegin(_etype216, _size213); + this->parts.resize(_size213); + uint32_t _i217; + for (_i217 = 0; _i217 < _size213; ++_i217) + { + xfer += this->parts[_i217].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_parts = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ifNotExists); + isset_ifNotExists = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->needResult); + this->__isset.needResult = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_parts) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_ifNotExists) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("AddPartitionsRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->parts.size())); + std::vector<Partition> ::const_iterator _iter218; + for (_iter218 = this->parts.begin(); _iter218 != this->parts.end(); ++_iter218) + { + xfer += (*_iter218).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("ifNotExists", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->ifNotExists); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.needResult) { + xfer += oprot->writeFieldBegin("needResult", ::apache::thrift::protocol::T_BOOL, 5); + xfer += oprot->writeBool(this->needResult); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.parts, b.parts); + swap(a.ifNotExists, b.ifNotExists); + swap(a.needResult, b.needResult); + swap(a.__isset, b.__isset); +} + const char* MetaException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; const uint8_t MetaException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1561947&r1=1561946&r2=1561947&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Tue Jan 28 05:48:03 2014 @@ -1976,18 +1976,18 @@ void swap(EnvironmentContext &a, Environ class PartitionsByExprResult { public: - static const char* ascii_fingerprint; // = "1B91CF0D2FC339DC29ABBD79CC9700E4"; - static const uint8_t binary_fingerprint[16]; // = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4}; + static const char* ascii_fingerprint; // = "40B789CC91B508FE36600A14E3F80425"; + static const uint8_t binary_fingerprint[16]; // = {0x40,0xB7,0x89,0xCC,0x91,0xB5,0x08,0xFE,0x36,0x60,0x0A,0x14,0xE3,0xF8,0x04,0x25}; PartitionsByExprResult() : hasUnknownPartitions(0) { } virtual ~PartitionsByExprResult() throw() {} - std::set<Partition> partitions; + std::vector<Partition> partitions; bool hasUnknownPartitions; - void __set_partitions(const std::set<Partition> & val) { + void __set_partitions(const std::vector<Partition> & val) { partitions = val; } @@ -2094,6 +2094,126 @@ class PartitionsByExprRequest { void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b); +typedef struct _AddPartitionsResult__isset { + _AddPartitionsResult__isset() : partitions(false) {} + bool partitions; +} _AddPartitionsResult__isset; + +class AddPartitionsResult { + public: + + static const char* ascii_fingerprint; // = "5A689D0823E7BFBB60C799BA60065C31"; + static const uint8_t binary_fingerprint[16]; // = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31}; + + AddPartitionsResult() { + } + + virtual ~AddPartitionsResult() throw() {} + + std::vector<Partition> partitions; + + _AddPartitionsResult__isset __isset; + + void __set_partitions(const std::vector<Partition> & val) { + partitions = val; + __isset.partitions = true; + } + + bool operator == (const AddPartitionsResult & rhs) const + { + if (__isset.partitions != rhs.__isset.partitions) + return false; + else if (__isset.partitions && !(partitions == rhs.partitions)) + return false; + return true; + } + bool operator != (const AddPartitionsResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPartitionsResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(AddPartitionsResult &a, AddPartitionsResult &b); + +typedef struct _AddPartitionsRequest__isset { + _AddPartitionsRequest__isset() : needResult(true) {} + bool needResult; +} _AddPartitionsRequest__isset; + +class AddPartitionsRequest { + public: + + static const char* ascii_fingerprint; // = "94F938D035892CF6873DEDB99358F069"; + static const uint8_t binary_fingerprint[16]; // = {0x94,0xF9,0x38,0xD0,0x35,0x89,0x2C,0xF6,0x87,0x3D,0xED,0xB9,0x93,0x58,0xF0,0x69}; + + AddPartitionsRequest() : dbName(), tblName(), ifNotExists(0), needResult(true) { + } + + virtual ~AddPartitionsRequest() throw() {} + + std::string dbName; + std::string tblName; + std::vector<Partition> parts; + bool ifNotExists; + bool needResult; + + _AddPartitionsRequest__isset __isset; + + void __set_dbName(const std::string& val) { + dbName = val; + } + + void __set_tblName(const std::string& val) { + tblName = val; + } + + void __set_parts(const std::vector<Partition> & val) { + parts = val; + } + + void __set_ifNotExists(const bool val) { + ifNotExists = val; + } + + void __set_needResult(const bool val) { + needResult = val; + __isset.needResult = true; + } + + bool operator == (const AddPartitionsRequest & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(parts == rhs.parts)) + return false; + if (!(ifNotExists == rhs.ifNotExists)) + return false; + if (__isset.needResult != rhs.__isset.needResult) + return false; + else if (__isset.needResult && !(needResult == rhs.needResult)) + return false; + return true; + } + bool operator != (const AddPartitionsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AddPartitionsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(AddPartitionsRequest &a, AddPartitionsRequest &b); + typedef struct _MetaException__isset { _MetaException__isset() : message(false) {} bool message; Modified: hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java?rev=1561947&r1=1561946&r2=1561947&view=diff ============================================================================== --- hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java (original) +++ hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java Tue Jan 28 05:48:03 2014 @@ -34,7 +34,7 @@ import org.slf4j.LoggerFactory; public class PartitionsByExprResult implements org.apache.thrift.TBase<PartitionsByExprResult, PartitionsByExprResult._Fields>, java.io.Serializable, Cloneable { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionsByExprResult"); - private static final org.apache.thrift.protocol.TField PARTITIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitions", org.apache.thrift.protocol.TType.SET, (short)1); + private static final org.apache.thrift.protocol.TField PARTITIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitions", org.apache.thrift.protocol.TType.LIST, (short)1); private static final org.apache.thrift.protocol.TField HAS_UNKNOWN_PARTITIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("hasUnknownPartitions", org.apache.thrift.protocol.TType.BOOL, (short)2); private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); @@ -43,7 +43,7 @@ public class PartitionsByExprResult impl schemes.put(TupleScheme.class, new PartitionsByExprResultTupleSchemeFactory()); } - private Set<Partition> partitions; // required + private List<Partition> partitions; // required private boolean hasUnknownPartitions; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ @@ -114,7 +114,7 @@ public class PartitionsByExprResult impl static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.PARTITIONS, new org.apache.thrift.meta_data.FieldMetaData("partitions", org.apache.thrift.TFieldRequirementType.REQUIRED, - new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Partition.class)))); tmpMap.put(_Fields.HAS_UNKNOWN_PARTITIONS, new org.apache.thrift.meta_data.FieldMetaData("hasUnknownPartitions", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); @@ -126,7 +126,7 @@ public class PartitionsByExprResult impl } public PartitionsByExprResult( - Set<Partition> partitions, + List<Partition> partitions, boolean hasUnknownPartitions) { this(); @@ -141,7 +141,7 @@ public class PartitionsByExprResult impl public PartitionsByExprResult(PartitionsByExprResult other) { __isset_bitfield = other.__isset_bitfield; if (other.isSetPartitions()) { - Set<Partition> __this__partitions = new HashSet<Partition>(); + List<Partition> __this__partitions = new ArrayList<Partition>(); for (Partition other_element : other.partitions) { __this__partitions.add(new Partition(other_element)); } @@ -171,16 +171,16 @@ public class PartitionsByExprResult impl public void addToPartitions(Partition elem) { if (this.partitions == null) { - this.partitions = new HashSet<Partition>(); + this.partitions = new ArrayList<Partition>(); } this.partitions.add(elem); } - public Set<Partition> getPartitions() { + public List<Partition> getPartitions() { return this.partitions; } - public void setPartitions(Set<Partition> partitions) { + public void setPartitions(List<Partition> partitions) { this.partitions = partitions; } @@ -227,7 +227,7 @@ public class PartitionsByExprResult impl if (value == null) { unsetPartitions(); } else { - setPartitions((Set<Partition>)value); + setPartitions((List<Partition>)value); } break; @@ -433,18 +433,18 @@ public class PartitionsByExprResult impl } switch (schemeField.id) { case 1: // PARTITIONS - if (schemeField.type == org.apache.thrift.protocol.TType.SET) { + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TSet _set256 = iprot.readSetBegin(); - struct.partitions = new HashSet<Partition>(2*_set256.size); - for (int _i257 = 0; _i257 < _set256.size; ++_i257) + org.apache.thrift.protocol.TList _list256 = iprot.readListBegin(); + struct.partitions = new ArrayList<Partition>(_list256.size); + for (int _i257 = 0; _i257 < _list256.size; ++_i257) { Partition _elem258; // required _elem258 = new Partition(); _elem258.read(iprot); struct.partitions.add(_elem258); } - iprot.readSetEnd(); + iprot.readListEnd(); } struct.setPartitionsIsSet(true); } else { @@ -475,12 +475,12 @@ public class PartitionsByExprResult impl if (struct.partitions != null) { oprot.writeFieldBegin(PARTITIONS_FIELD_DESC); { - oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size())); + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size())); for (Partition _iter259 : struct.partitions) { _iter259.write(oprot); } - oprot.writeSetEnd(); + oprot.writeListEnd(); } oprot.writeFieldEnd(); } @@ -518,9 +518,9 @@ public class PartitionsByExprResult impl public void read(org.apache.thrift.protocol.TProtocol prot, PartitionsByExprResult struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TSet _set261 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.partitions = new HashSet<Partition>(2*_set261.size); - for (int _i262 = 0; _i262 < _set261.size; ++_i262) + org.apache.thrift.protocol.TList _list261 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.partitions = new ArrayList<Partition>(_list261.size); + for (int _i262 = 0; _i262 < _list261.size; ++_i262) { Partition _elem263; // required _elem263 = new Partition();
