http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 6498eb1..df555ec 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -171,6 +171,9 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0; virtual void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) = 0; virtual void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) = 0; + virtual void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req) = 0; + virtual void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req) = 0; + virtual void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -675,6 +678,15 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void cache_file_metadata(CacheFileMetadataResult& /* _return */, const CacheFileMetadataRequest& /* req */) { return; } + void get_next_write_id(GetNextWriteIdResult& /* _return */, const GetNextWriteIdRequest& /* req */) { + return; + } + void finalize_write_id(FinalizeWriteIdResult& /* _return */, const FinalizeWriteIdRequest& /* req */) { + return; + } + void heartbeat_write_id(HeartbeatWriteIdResult& /* _return */, const HeartbeatWriteIdRequest& /* req */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -19131,6 +19143,318 @@ class ThriftHiveMetastore_cache_file_metadata_presult { }; +typedef struct _ThriftHiveMetastore_get_next_write_id_args__isset { + _ThriftHiveMetastore_get_next_write_id_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_get_next_write_id_args__isset; + +class ThriftHiveMetastore_get_next_write_id_args { + public: + + ThriftHiveMetastore_get_next_write_id_args(const ThriftHiveMetastore_get_next_write_id_args&); + ThriftHiveMetastore_get_next_write_id_args& operator=(const ThriftHiveMetastore_get_next_write_id_args&); + ThriftHiveMetastore_get_next_write_id_args() { + } + + virtual ~ThriftHiveMetastore_get_next_write_id_args() throw(); + GetNextWriteIdRequest req; + + _ThriftHiveMetastore_get_next_write_id_args__isset __isset; + + void __set_req(const GetNextWriteIdRequest& val); + + bool operator == (const ThriftHiveMetastore_get_next_write_id_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_next_write_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_next_write_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_next_write_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_next_write_id_pargs() throw(); + const GetNextWriteIdRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_next_write_id_result__isset { + _ThriftHiveMetastore_get_next_write_id_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_next_write_id_result__isset; + +class ThriftHiveMetastore_get_next_write_id_result { + public: + + ThriftHiveMetastore_get_next_write_id_result(const ThriftHiveMetastore_get_next_write_id_result&); + ThriftHiveMetastore_get_next_write_id_result& operator=(const ThriftHiveMetastore_get_next_write_id_result&); + ThriftHiveMetastore_get_next_write_id_result() { + } + + virtual ~ThriftHiveMetastore_get_next_write_id_result() throw(); + GetNextWriteIdResult success; + + _ThriftHiveMetastore_get_next_write_id_result__isset __isset; + + void __set_success(const GetNextWriteIdResult& val); + + bool operator == (const ThriftHiveMetastore_get_next_write_id_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_next_write_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_next_write_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_next_write_id_presult__isset { + _ThriftHiveMetastore_get_next_write_id_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_next_write_id_presult__isset; + +class ThriftHiveMetastore_get_next_write_id_presult { + public: + + + virtual ~ThriftHiveMetastore_get_next_write_id_presult() throw(); + GetNextWriteIdResult* success; + + _ThriftHiveMetastore_get_next_write_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_finalize_write_id_args__isset { + _ThriftHiveMetastore_finalize_write_id_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_finalize_write_id_args__isset; + +class ThriftHiveMetastore_finalize_write_id_args { + public: + + ThriftHiveMetastore_finalize_write_id_args(const ThriftHiveMetastore_finalize_write_id_args&); + ThriftHiveMetastore_finalize_write_id_args& operator=(const ThriftHiveMetastore_finalize_write_id_args&); + ThriftHiveMetastore_finalize_write_id_args() { + } + + virtual ~ThriftHiveMetastore_finalize_write_id_args() throw(); + FinalizeWriteIdRequest req; + + _ThriftHiveMetastore_finalize_write_id_args__isset __isset; + + void __set_req(const FinalizeWriteIdRequest& val); + + bool operator == (const ThriftHiveMetastore_finalize_write_id_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_finalize_write_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_finalize_write_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_finalize_write_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_finalize_write_id_pargs() throw(); + const FinalizeWriteIdRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_finalize_write_id_result__isset { + _ThriftHiveMetastore_finalize_write_id_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_finalize_write_id_result__isset; + +class ThriftHiveMetastore_finalize_write_id_result { + public: + + ThriftHiveMetastore_finalize_write_id_result(const ThriftHiveMetastore_finalize_write_id_result&); + ThriftHiveMetastore_finalize_write_id_result& operator=(const ThriftHiveMetastore_finalize_write_id_result&); + ThriftHiveMetastore_finalize_write_id_result() { + } + + virtual ~ThriftHiveMetastore_finalize_write_id_result() throw(); + FinalizeWriteIdResult success; + + _ThriftHiveMetastore_finalize_write_id_result__isset __isset; + + void __set_success(const FinalizeWriteIdResult& val); + + bool operator == (const ThriftHiveMetastore_finalize_write_id_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_finalize_write_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_finalize_write_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_finalize_write_id_presult__isset { + _ThriftHiveMetastore_finalize_write_id_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_finalize_write_id_presult__isset; + +class ThriftHiveMetastore_finalize_write_id_presult { + public: + + + virtual ~ThriftHiveMetastore_finalize_write_id_presult() throw(); + FinalizeWriteIdResult* success; + + _ThriftHiveMetastore_finalize_write_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_write_id_args__isset { + _ThriftHiveMetastore_heartbeat_write_id_args__isset() : req(false) {} + bool req :1; +} _ThriftHiveMetastore_heartbeat_write_id_args__isset; + +class ThriftHiveMetastore_heartbeat_write_id_args { + public: + + ThriftHiveMetastore_heartbeat_write_id_args(const ThriftHiveMetastore_heartbeat_write_id_args&); + ThriftHiveMetastore_heartbeat_write_id_args& operator=(const ThriftHiveMetastore_heartbeat_write_id_args&); + ThriftHiveMetastore_heartbeat_write_id_args() { + } + + virtual ~ThriftHiveMetastore_heartbeat_write_id_args() throw(); + HeartbeatWriteIdRequest req; + + _ThriftHiveMetastore_heartbeat_write_id_args__isset __isset; + + void __set_req(const HeartbeatWriteIdRequest& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_write_id_args & rhs) const + { + if (!(req == rhs.req)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_heartbeat_write_id_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_write_id_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_heartbeat_write_id_pargs { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_write_id_pargs() throw(); + const HeartbeatWriteIdRequest* req; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_write_id_result__isset { + _ThriftHiveMetastore_heartbeat_write_id_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_write_id_result__isset; + +class ThriftHiveMetastore_heartbeat_write_id_result { + public: + + ThriftHiveMetastore_heartbeat_write_id_result(const ThriftHiveMetastore_heartbeat_write_id_result&); + ThriftHiveMetastore_heartbeat_write_id_result& operator=(const ThriftHiveMetastore_heartbeat_write_id_result&); + ThriftHiveMetastore_heartbeat_write_id_result() { + } + + virtual ~ThriftHiveMetastore_heartbeat_write_id_result() throw(); + HeartbeatWriteIdResult success; + + _ThriftHiveMetastore_heartbeat_write_id_result__isset __isset; + + void __set_success(const HeartbeatWriteIdResult& val); + + bool operator == (const ThriftHiveMetastore_heartbeat_write_id_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_heartbeat_write_id_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_heartbeat_write_id_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_heartbeat_write_id_presult__isset { + _ThriftHiveMetastore_heartbeat_write_id_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_heartbeat_write_id_presult__isset; + +class ThriftHiveMetastore_heartbeat_write_id_presult { + public: + + + virtual ~ThriftHiveMetastore_heartbeat_write_id_presult() throw(); + HeartbeatWriteIdResult* success; + + _ThriftHiveMetastore_heartbeat_write_id_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient { public: ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : @@ -19589,6 +19913,15 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req); void send_cache_file_metadata(const CacheFileMetadataRequest& req); void recv_cache_file_metadata(CacheFileMetadataResult& _return); + void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req); + void send_get_next_write_id(const GetNextWriteIdRequest& req); + void recv_get_next_write_id(GetNextWriteIdResult& _return); + void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req); + void send_finalize_write_id(const FinalizeWriteIdRequest& req); + void recv_finalize_write_id(FinalizeWriteIdResult& _return); + void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req); + void send_heartbeat_write_id(const HeartbeatWriteIdRequest& req); + void recv_heartbeat_write_id(HeartbeatWriteIdResult& _return); }; class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceProcessor { @@ -19748,6 +20081,9 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_clear_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_cache_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_next_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_finalize_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_heartbeat_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); public: ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) : ::facebook::fb303::FacebookServiceProcessor(iface), @@ -19901,6 +20237,9 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata; processMap_["clear_file_metadata"] = &ThriftHiveMetastoreProcessor::process_clear_file_metadata; processMap_["cache_file_metadata"] = &ThriftHiveMetastoreProcessor::process_cache_file_metadata; + processMap_["get_next_write_id"] = &ThriftHiveMetastoreProcessor::process_get_next_write_id; + processMap_["finalize_write_id"] = &ThriftHiveMetastoreProcessor::process_finalize_write_id; + processMap_["heartbeat_write_id"] = &ThriftHiveMetastoreProcessor::process_heartbeat_write_id; } virtual ~ThriftHiveMetastoreProcessor() {} @@ -21361,6 +21700,36 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_next_write_id(_return, req); + } + ifaces_[i]->get_next_write_id(_return, req); + return; + } + + void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->finalize_write_id(_return, req); + } + ifaces_[i]->finalize_write_id(_return, req); + return; + } + + void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->heartbeat_write_id(_return, req); + } + ifaces_[i]->heartbeat_write_id(_return, req); + return; + } + }; // The 'concurrent' client is a thread safe client that correctly handles @@ -21824,6 +22193,15 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req); int32_t send_cache_file_metadata(const CacheFileMetadataRequest& req); void recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid); + void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req); + int32_t send_get_next_write_id(const GetNextWriteIdRequest& req); + void recv_get_next_write_id(GetNextWriteIdResult& _return, const int32_t seqid); + void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req); + int32_t send_finalize_write_id(const FinalizeWriteIdRequest& req); + void recv_finalize_write_id(FinalizeWriteIdResult& _return, const int32_t seqid); + void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req); + int32_t send_heartbeat_write_id(const HeartbeatWriteIdRequest& req); + void recv_heartbeat_write_id(HeartbeatWriteIdResult& _return, const int32_t seqid); }; #ifdef _WIN32
http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp ---------------------------------------------------------------------- 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 3330b2f..317598e 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -767,6 +767,21 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("cache_file_metadata\n"); } + void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req) { + // Your implementation goes here + printf("get_next_write_id\n"); + } + + void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req) { + // Your implementation goes here + printf("finalize_write_id\n"); + } + + void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req) { + // Your implementation goes here + printf("heartbeat_write_id\n"); + } + }; int main(int argc, char **argv) { http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp index 1cbd176..ccc61cb 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp @@ -59,6 +59,8 @@ hive_metastoreConstants::hive_metastoreConstants() { TABLE_TRANSACTIONAL_PROPERTIES = "transactional_properties"; + TABLE_IS_MM = "hivecommit"; + } }}} // namespace http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h index 3d068c3..92a2116 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_constants.h @@ -39,6 +39,7 @@ class hive_metastoreConstants { std::string TABLE_IS_TRANSACTIONAL; std::string TABLE_NO_AUTO_COMPACT; std::string TABLE_TRANSACTIONAL_PROPERTIES; + std::string TABLE_IS_MM; }; extern const hive_metastoreConstants g_hive_metastore_constants; http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 174b539..bdfa35b 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -4471,6 +4471,16 @@ void Table::__set_temporary(const bool val) { __isset.temporary = true; } +void Table::__set_mmNextWriteId(const int64_t val) { + this->mmNextWriteId = val; +__isset.mmNextWriteId = true; +} + +void Table::__set_mmWatermarkWriteId(const int64_t val) { + this->mmWatermarkWriteId = val; +__isset.mmWatermarkWriteId = true; +} + uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -4631,6 +4641,22 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 15: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->mmNextWriteId); + this->__isset.mmNextWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 16: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->mmWatermarkWriteId); + this->__isset.mmWatermarkWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4723,6 +4749,16 @@ uint32_t Table::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeBool(this->temporary); xfer += oprot->writeFieldEnd(); } + if (this->__isset.mmNextWriteId) { + xfer += oprot->writeFieldBegin("mmNextWriteId", ::apache::thrift::protocol::T_I64, 15); + xfer += oprot->writeI64(this->mmNextWriteId); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.mmWatermarkWriteId) { + xfer += oprot->writeFieldBegin("mmWatermarkWriteId", ::apache::thrift::protocol::T_I64, 16); + xfer += oprot->writeI64(this->mmWatermarkWriteId); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -4744,6 +4780,8 @@ void swap(Table &a, Table &b) { swap(a.tableType, b.tableType); swap(a.privileges, b.privileges); swap(a.temporary, b.temporary); + swap(a.mmNextWriteId, b.mmNextWriteId); + swap(a.mmWatermarkWriteId, b.mmWatermarkWriteId); swap(a.__isset, b.__isset); } @@ -4762,6 +4800,8 @@ Table::Table(const Table& other221) { tableType = other221.tableType; privileges = other221.privileges; temporary = other221.temporary; + mmNextWriteId = other221.mmNextWriteId; + mmWatermarkWriteId = other221.mmWatermarkWriteId; __isset = other221.__isset; } Table& Table::operator=(const Table& other222) { @@ -4779,6 +4819,8 @@ Table& Table::operator=(const Table& other222) { tableType = other222.tableType; privileges = other222.privileges; temporary = other222.temporary; + mmNextWriteId = other222.mmNextWriteId; + mmWatermarkWriteId = other222.mmWatermarkWriteId; __isset = other222.__isset; return *this; } @@ -4799,6 +4841,8 @@ void Table::printTo(std::ostream& out) const { out << ", " << "tableType=" << to_string(tableType); out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "<null>")); out << ", " << "temporary="; (__isset.temporary ? (out << to_string(temporary)) : (out << "<null>")); + out << ", " << "mmNextWriteId="; (__isset.mmNextWriteId ? (out << to_string(mmNextWriteId)) : (out << "<null>")); + out << ", " << "mmWatermarkWriteId="; (__isset.mmWatermarkWriteId ? (out << to_string(mmWatermarkWriteId)) : (out << "<null>")); out << ")"; } @@ -17610,16 +17654,19 @@ void CacheFileMetadataRequest::printTo(std::ostream& out) const { } -GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() { +GetNextWriteIdRequest::~GetNextWriteIdRequest() throw() { } -void GetAllFunctionsResponse::__set_functions(const std::vector<Function> & val) { - this->functions = val; -__isset.functions = true; +void GetNextWriteIdRequest::__set_dbName(const std::string& val) { + this->dbName = val; } -uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { +void GetNextWriteIdRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +uint32_t GetNextWriteIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17631,6 +17678,8 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip using ::apache::thrift::protocol::TProtocolException; + bool isset_dbName = false; + bool isset_tblName = false; while (true) { @@ -17641,21 +17690,17 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->functions.clear(); - uint32_t _size739; - ::apache::thrift::protocol::TType _etype742; - xfer += iprot->readListBegin(_etype742, _size739); - this->functions.resize(_size739); - uint32_t _i743; - for (_i743 = 0; _i743 < _size739; ++_i743) - { - xfer += this->functions[_i743].read(iprot); - } - xfer += iprot->readListEnd(); - } - this->__isset.functions = true; + 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); } @@ -17669,77 +17714,162 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip xfer += iprot->readStructEnd(); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } -uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t GetNextWriteIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("GetAllFunctionsResponse"); + xfer += oprot->writeStructBegin("GetNextWriteIdRequest"); - if (this->__isset.functions) { - xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); + 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->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b) { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); +} + +GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other739) { + dbName = other739.dbName; + tblName = other739.tblName; +} +GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other740) { + dbName = other740.dbName; + tblName = other740.tblName; + return *this; +} +void GetNextWriteIdRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetNextWriteIdRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ")"; +} + + +GetNextWriteIdResult::~GetNextWriteIdResult() throw() { +} + + +void GetNextWriteIdResult::__set_writeId(const int64_t val) { + this->writeId = val; +} + +uint32_t GetNextWriteIdResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_writeId = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size())); - std::vector<Function> ::const_iterator _iter744; - for (_iter744 = this->functions.begin(); _iter744 != this->functions.end(); ++_iter744) - { - xfer += (*_iter744).write(oprot); - } - xfer += oprot->writeListEnd(); + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; } - xfer += oprot->writeFieldEnd(); + xfer += iprot->readFieldEnd(); } + + xfer += iprot->readStructEnd(); + + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetNextWriteIdResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetNextWriteIdResult"); + + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { +void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b) { using ::std::swap; - swap(a.functions, b.functions); - swap(a.__isset, b.__isset); + swap(a.writeId, b.writeId); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other745) { - functions = other745.functions; - __isset = other745.__isset; +GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other741) { + writeId = other741.writeId; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other746) { - functions = other746.functions; - __isset = other746.__isset; +GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other742) { + writeId = other742.writeId; return *this; } -void GetAllFunctionsResponse::printTo(std::ostream& out) const { +void GetNextWriteIdResult::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "GetAllFunctionsResponse("; - out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>")); + out << "GetNextWriteIdResult("; + out << "writeId=" << to_string(writeId); out << ")"; } -TableMeta::~TableMeta() throw() { +FinalizeWriteIdRequest::~FinalizeWriteIdRequest() throw() { } -void TableMeta::__set_dbName(const std::string& val) { +void FinalizeWriteIdRequest::__set_dbName(const std::string& val) { this->dbName = val; } -void TableMeta::__set_tableName(const std::string& val) { - this->tableName = val; +void FinalizeWriteIdRequest::__set_tblName(const std::string& val) { + this->tblName = val; } -void TableMeta::__set_tableType(const std::string& val) { - this->tableType = val; +void FinalizeWriteIdRequest::__set_writeId(const int64_t val) { + this->writeId = val; } -void TableMeta::__set_comments(const std::string& val) { - this->comments = val; -__isset.comments = true; +void FinalizeWriteIdRequest::__set_commit(const bool val) { + this->commit = val; } -uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t FinalizeWriteIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17752,8 +17882,9 @@ uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { using ::apache::thrift::protocol::TProtocolException; bool isset_dbName = false; - bool isset_tableName = false; - bool isset_tableType = false; + bool isset_tblName = false; + bool isset_writeId = false; + bool isset_commit = false; while (true) { @@ -17773,24 +17904,24 @@ uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tableName); - isset_tableName = true; + xfer += iprot->readString(this->tblName); + isset_tblName = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tableType); - isset_tableType = true; + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; } else { xfer += iprot->skip(ftype); } break; case 4: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->comments); - this->__isset.comments = true; + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->commit); + isset_commit = true; } else { xfer += iprot->skip(ftype); } @@ -17806,84 +17937,78 @@ uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { if (!isset_dbName) throw TProtocolException(TProtocolException::INVALID_DATA); - if (!isset_tableName) + if (!isset_tblName) throw TProtocolException(TProtocolException::INVALID_DATA); - if (!isset_tableType) + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_commit) throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } -uint32_t TableMeta::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t FinalizeWriteIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("TableMeta"); + xfer += oprot->writeStructBegin("FinalizeWriteIdRequest"); xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->dbName); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("commit", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->commit); xfer += oprot->writeFieldEnd(); - if (this->__isset.comments) { - xfer += oprot->writeFieldBegin("comments", ::apache::thrift::protocol::T_STRING, 4); - xfer += oprot->writeString(this->comments); - xfer += oprot->writeFieldEnd(); - } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(TableMeta &a, TableMeta &b) { +void swap(FinalizeWriteIdRequest &a, FinalizeWriteIdRequest &b) { using ::std::swap; swap(a.dbName, b.dbName); - swap(a.tableName, b.tableName); - swap(a.tableType, b.tableType); - swap(a.comments, b.comments); - swap(a.__isset, b.__isset); + swap(a.tblName, b.tblName); + swap(a.writeId, b.writeId); + swap(a.commit, b.commit); } -TableMeta::TableMeta(const TableMeta& other747) { - dbName = other747.dbName; - tableName = other747.tableName; - tableType = other747.tableType; - comments = other747.comments; - __isset = other747.__isset; +FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other743) { + dbName = other743.dbName; + tblName = other743.tblName; + writeId = other743.writeId; + commit = other743.commit; } -TableMeta& TableMeta::operator=(const TableMeta& other748) { - dbName = other748.dbName; - tableName = other748.tableName; - tableType = other748.tableType; - comments = other748.comments; - __isset = other748.__isset; +FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other744) { + dbName = other744.dbName; + tblName = other744.tblName; + writeId = other744.writeId; + commit = other744.commit; return *this; } -void TableMeta::printTo(std::ostream& out) const { +void FinalizeWriteIdRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "TableMeta("; + out << "FinalizeWriteIdRequest("; out << "dbName=" << to_string(dbName); - out << ", " << "tableName=" << to_string(tableName); - out << ", " << "tableType=" << to_string(tableType); - out << ", " << "comments="; (__isset.comments ? (out << to_string(comments)) : (out << "<null>")); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "writeId=" << to_string(writeId); + out << ", " << "commit=" << to_string(commit); out << ")"; } -MetaException::~MetaException() throw() { +FinalizeWriteIdResult::~FinalizeWriteIdResult() throw() { } -void MetaException::__set_message(const std::string& val) { - this->message = val; -} - -uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t FinalizeWriteIdResult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -17902,20 +18027,7 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_STOP) { break; } - switch (fid) - { - case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->message); - this->__isset.message = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } + xfer += iprot->skip(ftype); xfer += iprot->readFieldEnd(); } @@ -17924,63 +18036,601 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { return xfer; } -uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t FinalizeWriteIdResult::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("MetaException"); - - xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->message); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("FinalizeWriteIdResult"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -void swap(MetaException &a, MetaException &b) { +void swap(FinalizeWriteIdResult &a, FinalizeWriteIdResult &b) { using ::std::swap; - swap(a.message, b.message); - swap(a.__isset, b.__isset); + (void) a; + (void) b; } -MetaException::MetaException(const MetaException& other749) : TException() { - message = other749.message; - __isset = other749.__isset; +FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other745) { + (void) other745; } -MetaException& MetaException::operator=(const MetaException& other750) { - message = other750.message; - __isset = other750.__isset; +FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other746) { + (void) other746; return *this; } -void MetaException::printTo(std::ostream& out) const { +void FinalizeWriteIdResult::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "MetaException("; - out << "message=" << to_string(message); + out << "FinalizeWriteIdResult("; out << ")"; } -const char* MetaException::what() const throw() { - try { - std::stringstream ss; - ss << "TException - service has thrown: " << *this; - this->thriftTExceptionMessageHolder_ = ss.str(); - return this->thriftTExceptionMessageHolder_.c_str(); - } catch (const std::exception&) { - return "TException - service has thrown: MetaException"; - } + +HeartbeatWriteIdRequest::~HeartbeatWriteIdRequest() throw() { } -UnknownTableException::~UnknownTableException() throw() { +void HeartbeatWriteIdRequest::__set_dbName(const std::string& val) { + this->dbName = val; } +void HeartbeatWriteIdRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} -void UnknownTableException::__set_message(const std::string& val) { - this->message = val; +void HeartbeatWriteIdRequest::__set_writeId(const int64_t val) { + this->writeId = val; } -uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t HeartbeatWriteIdRequest::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tblName = false; + bool isset_writeId = 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_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = 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_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t HeartbeatWriteIdRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HeartbeatWriteIdRequest"); + + 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("writeId", ::apache::thrift::protocol::T_I64, 3); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HeartbeatWriteIdRequest &a, HeartbeatWriteIdRequest &b) { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.writeId, b.writeId); +} + +HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other747) { + dbName = other747.dbName; + tblName = other747.tblName; + writeId = other747.writeId; +} +HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other748) { + dbName = other748.dbName; + tblName = other748.tblName; + writeId = other748.writeId; + return *this; +} +void HeartbeatWriteIdRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HeartbeatWriteIdRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "writeId=" << to_string(writeId); + out << ")"; +} + + +HeartbeatWriteIdResult::~HeartbeatWriteIdResult() throw() { +} + + +uint32_t HeartbeatWriteIdResult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + xfer += iprot->skip(ftype); + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t HeartbeatWriteIdResult::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("HeartbeatWriteIdResult"); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(HeartbeatWriteIdResult &a, HeartbeatWriteIdResult &b) { + using ::std::swap; + (void) a; + (void) b; +} + +HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other749) { + (void) other749; +} +HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other750) { + (void) other750; + return *this; +} +void HeartbeatWriteIdResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "HeartbeatWriteIdResult("; + out << ")"; +} + + +GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() { +} + + +void GetAllFunctionsResponse::__set_functions(const std::vector<Function> & val) { + this->functions = val; +__isset.functions = true; +} + +uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->functions.clear(); + uint32_t _size751; + ::apache::thrift::protocol::TType _etype754; + xfer += iprot->readListBegin(_etype754, _size751); + this->functions.resize(_size751); + uint32_t _i755; + for (_i755 = 0; _i755 < _size751; ++_i755) + { + xfer += this->functions[_i755].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.functions = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetAllFunctionsResponse"); + + if (this->__isset.functions) { + xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size())); + std::vector<Function> ::const_iterator _iter756; + for (_iter756 = this->functions.begin(); _iter756 != this->functions.end(); ++_iter756) + { + xfer += (*_iter756).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { + using ::std::swap; + swap(a.functions, b.functions); + swap(a.__isset, b.__isset); +} + +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other757) { + functions = other757.functions; + __isset = other757.__isset; +} +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other758) { + functions = other758.functions; + __isset = other758.__isset; + return *this; +} +void GetAllFunctionsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetAllFunctionsResponse("; + out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>")); + out << ")"; +} + + +TableMeta::~TableMeta() throw() { +} + + +void TableMeta::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void TableMeta::__set_tableName(const std::string& val) { + this->tableName = val; +} + +void TableMeta::__set_tableType(const std::string& val) { + this->tableType = val; +} + +void TableMeta::__set_comments(const std::string& val) { + this->comments = val; +__isset.comments = true; +} + +uint32_t TableMeta::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_dbName = false; + bool isset_tableName = false; + bool isset_tableType = 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->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + isset_tableType = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->comments); + this->__isset.comments = 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_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableType) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableMeta::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableMeta"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.comments) { + xfer += oprot->writeFieldBegin("comments", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeString(this->comments); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableMeta &a, TableMeta &b) { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); + swap(a.tableType, b.tableType); + swap(a.comments, b.comments); + swap(a.__isset, b.__isset); +} + +TableMeta::TableMeta(const TableMeta& other759) { + dbName = other759.dbName; + tableName = other759.tableName; + tableType = other759.tableType; + comments = other759.comments; + __isset = other759.__isset; +} +TableMeta& TableMeta::operator=(const TableMeta& other760) { + dbName = other760.dbName; + tableName = other760.tableName; + tableType = other760.tableType; + comments = other760.comments; + __isset = other760.__isset; + return *this; +} +void TableMeta::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableMeta("; + out << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ", " << "tableType=" << to_string(tableType); + out << ", " << "comments="; (__isset.comments ? (out << to_string(comments)) : (out << "<null>")); + out << ")"; +} + + +MetaException::~MetaException() throw() { +} + + +void MetaException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->message); + this->__isset.message = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("MetaException"); + + xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->message); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(MetaException &a, MetaException &b) { + using ::std::swap; + swap(a.message, b.message); + swap(a.__isset, b.__isset); +} + +MetaException::MetaException(const MetaException& other761) : TException() { + message = other761.message; + __isset = other761.__isset; +} +MetaException& MetaException::operator=(const MetaException& other762) { + message = other762.message; + __isset = other762.__isset; + return *this; +} +void MetaException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "MetaException("; + out << "message=" << to_string(message); + out << ")"; +} + +const char* MetaException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: MetaException"; + } +} + + +UnknownTableException::~UnknownTableException() throw() { +} + + +void UnknownTableException::__set_message(const std::string& val) { + this->message = val; +} + +uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -18041,13 +18691,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other751) : TException() { - message = other751.message; - __isset = other751.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other763) : TException() { + message = other763.message; + __isset = other763.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other752) { - message = other752.message; - __isset = other752.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other764) { + message = other764.message; + __isset = other764.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -18138,13 +18788,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other753) : TException() { - message = other753.message; - __isset = other753.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other765) : TException() { + message = other765.message; + __isset = other765.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other754) { - message = other754.message; - __isset = other754.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other766) { + message = other766.message; + __isset = other766.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -18235,13 +18885,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other755) : TException() { - message = other755.message; - __isset = other755.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other767) : TException() { + message = other767.message; + __isset = other767.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other756) { - message = other756.message; - __isset = other756.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other768) { + message = other768.message; + __isset = other768.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -18332,13 +18982,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other757) : TException() { - message = other757.message; - __isset = other757.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other769) : TException() { + message = other769.message; + __isset = other769.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other758) { - message = other758.message; - __isset = other758.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other770) { + message = other770.message; + __isset = other770.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -18429,13 +19079,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other759) : TException() { - message = other759.message; - __isset = other759.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other771) : TException() { + message = other771.message; + __isset = other771.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other760) { - message = other760.message; - __isset = other760.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other772) { + message = other772.message; + __isset = other772.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -18526,13 +19176,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other761) : TException() { - message = other761.message; - __isset = other761.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other773) : TException() { + message = other773.message; + __isset = other773.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other762) { - message = other762.message; - __isset = other762.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other774) { + message = other774.message; + __isset = other774.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -18623,13 +19273,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other763) : TException() { - message = other763.message; - __isset = other763.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other775) : TException() { + message = other775.message; + __isset = other775.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other764) { - message = other764.message; - __isset = other764.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other776) { + message = other776.message; + __isset = other776.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -18720,13 +19370,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other765) : TException() { - message = other765.message; - __isset = other765.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other777) : TException() { + message = other777.message; + __isset = other777.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other766) { - message = other766.message; - __isset = other766.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other778) { + message = other778.message; + __isset = other778.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -18817,13 +19467,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other767) : TException() { - message = other767.message; - __isset = other767.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other779) : TException() { + message = other779.message; + __isset = other779.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other768) { - message = other768.message; - __isset = other768.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other780) { + message = other780.message; + __isset = other780.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -18914,13 +19564,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other769) : TException() { - message = other769.message; - __isset = other769.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other781) : TException() { + message = other781.message; + __isset = other781.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other770) { - message = other770.message; - __isset = other770.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other782) { + message = other782.message; + __isset = other782.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -19011,13 +19661,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other771) : TException() { - message = other771.message; - __isset = other771.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other783) : TException() { + message = other783.message; + __isset = other783.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other772) { - message = other772.message; - __isset = other772.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other784) { + message = other784.message; + __isset = other784.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -19108,13 +19758,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other773) : TException() { - message = other773.message; - __isset = other773.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other785) : TException() { + message = other785.message; + __isset = other785.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other774) { - message = other774.message; - __isset = other774.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other786) { + message = other786.message; + __isset = other786.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -19205,13 +19855,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other775) : TException() { - message = other775.message; - __isset = other775.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other787) : TException() { + message = other787.message; + __isset = other787.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other776) { - message = other776.message; - __isset = other776.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other788) { + message = other788.message; + __isset = other788.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -19302,13 +19952,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other777) : TException() { - message = other777.message; - __isset = other777.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other789) : TException() { + message = other789.message; + __isset = other789.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other778) { - message = other778.message; - __isset = other778.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other790) { + message = other790.message; + __isset = other790.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -19399,13 +20049,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other779) : TException() { - message = other779.message; - __isset = other779.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other791) : TException() { + message = other791.message; + __isset = other791.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other780) { - message = other780.message; - __isset = other780.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other792) { + message = other792.message; + __isset = other792.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { http://git-wip-us.apache.org/repos/asf/hive/blob/30fd19f4/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index bfec694..beddd4c 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -384,6 +384,18 @@ class CacheFileMetadataResult; class CacheFileMetadataRequest; +class GetNextWriteIdRequest; + +class GetNextWriteIdResult; + +class FinalizeWriteIdRequest; + +class FinalizeWriteIdResult; + +class HeartbeatWriteIdRequest; + +class HeartbeatWriteIdResult; + class GetAllFunctionsResponse; class TableMeta; @@ -2042,7 +2054,7 @@ inline std::ostream& operator<<(std::ostream& out, const StorageDescriptor& obj) } typedef struct _Table__isset { - _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true) {} + _Table__isset() : tableName(false), dbName(false), owner(false), createTime(false), lastAccessTime(false), retention(false), sd(false), partitionKeys(false), parameters(false), viewOriginalText(false), viewExpandedText(false), tableType(false), privileges(false), temporary(true), mmNextWriteId(false), mmWatermarkWriteId(false) {} bool tableName :1; bool dbName :1; bool owner :1; @@ -2057,6 +2069,8 @@ typedef struct _Table__isset { bool tableType :1; bool privileges :1; bool temporary :1; + bool mmNextWriteId :1; + bool mmWatermarkWriteId :1; } _Table__isset; class Table { @@ -2064,7 +2078,7 @@ class Table { Table(const Table&); Table& operator=(const Table&); - Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false) { + Table() : tableName(), dbName(), owner(), createTime(0), lastAccessTime(0), retention(0), viewOriginalText(), viewExpandedText(), tableType(), temporary(false), mmNextWriteId(0), mmWatermarkWriteId(0) { } virtual ~Table() throw(); @@ -2082,6 +2096,8 @@ class Table { std::string tableType; PrincipalPrivilegeSet privileges; bool temporary; + int64_t mmNextWriteId; + int64_t mmWatermarkWriteId; _Table__isset __isset; @@ -2113,6 +2129,10 @@ class Table { void __set_temporary(const bool val); + void __set_mmNextWriteId(const int64_t val); + + void __set_mmWatermarkWriteId(const int64_t val); + bool operator == (const Table & rhs) const { if (!(tableName == rhs.tableName)) @@ -2147,6 +2167,14 @@ class Table { return false; else if (__isset.temporary && !(temporary == rhs.temporary)) return false; + if (__isset.mmNextWriteId != rhs.__isset.mmNextWriteId) + return false; + else if (__isset.mmNextWriteId && !(mmNextWriteId == rhs.mmNextWriteId)) + return false; + if (__isset.mmWatermarkWriteId != rhs.__isset.mmWatermarkWriteId) + return false; + else if (__isset.mmWatermarkWriteId && !(mmWatermarkWriteId == rhs.mmWatermarkWriteId)) + return false; return true; } bool operator != (const Table &rhs) const { @@ -7157,6 +7185,266 @@ inline std::ostream& operator<<(std::ostream& out, const CacheFileMetadataReques return out; } + +class GetNextWriteIdRequest { + public: + + GetNextWriteIdRequest(const GetNextWriteIdRequest&); + GetNextWriteIdRequest& operator=(const GetNextWriteIdRequest&); + GetNextWriteIdRequest() : dbName(), tblName() { + } + + virtual ~GetNextWriteIdRequest() throw(); + std::string dbName; + std::string tblName; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + bool operator == (const GetNextWriteIdRequest & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + return true; + } + bool operator != (const GetNextWriteIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetNextWriteIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const GetNextWriteIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class GetNextWriteIdResult { + public: + + GetNextWriteIdResult(const GetNextWriteIdResult&); + GetNextWriteIdResult& operator=(const GetNextWriteIdResult&); + GetNextWriteIdResult() : writeId(0) { + } + + virtual ~GetNextWriteIdResult() throw(); + int64_t writeId; + + void __set_writeId(const int64_t val); + + bool operator == (const GetNextWriteIdResult & rhs) const + { + if (!(writeId == rhs.writeId)) + return false; + return true; + } + bool operator != (const GetNextWriteIdResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const GetNextWriteIdResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b); + +inline std::ostream& operator<<(std::ostream& out, const GetNextWriteIdResult& obj) +{ + obj.printTo(out); + return out; +} + + +class FinalizeWriteIdRequest { + public: + + FinalizeWriteIdRequest(const FinalizeWriteIdRequest&); + FinalizeWriteIdRequest& operator=(const FinalizeWriteIdRequest&); + FinalizeWriteIdRequest() : dbName(), tblName(), writeId(0), commit(0) { + } + + virtual ~FinalizeWriteIdRequest() throw(); + std::string dbName; + std::string tblName; + int64_t writeId; + bool commit; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_writeId(const int64_t val); + + void __set_commit(const bool val); + + bool operator == (const FinalizeWriteIdRequest & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(writeId == rhs.writeId)) + return false; + if (!(commit == rhs.commit)) + return false; + return true; + } + bool operator != (const FinalizeWriteIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FinalizeWriteIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FinalizeWriteIdRequest &a, FinalizeWriteIdRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const FinalizeWriteIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class FinalizeWriteIdResult { + public: + + FinalizeWriteIdResult(const FinalizeWriteIdResult&); + FinalizeWriteIdResult& operator=(const FinalizeWriteIdResult&); + FinalizeWriteIdResult() { + } + + virtual ~FinalizeWriteIdResult() throw(); + + bool operator == (const FinalizeWriteIdResult & /* rhs */) const + { + return true; + } + bool operator != (const FinalizeWriteIdResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const FinalizeWriteIdResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(FinalizeWriteIdResult &a, FinalizeWriteIdResult &b); + +inline std::ostream& operator<<(std::ostream& out, const FinalizeWriteIdResult& obj) +{ + obj.printTo(out); + return out; +} + + +class HeartbeatWriteIdRequest { + public: + + HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest&); + HeartbeatWriteIdRequest& operator=(const HeartbeatWriteIdRequest&); + HeartbeatWriteIdRequest() : dbName(), tblName(), writeId(0) { + } + + virtual ~HeartbeatWriteIdRequest() throw(); + std::string dbName; + std::string tblName; + int64_t writeId; + + void __set_dbName(const std::string& val); + + void __set_tblName(const std::string& val); + + void __set_writeId(const int64_t val); + + bool operator == (const HeartbeatWriteIdRequest & rhs) const + { + if (!(dbName == rhs.dbName)) + return false; + if (!(tblName == rhs.tblName)) + return false; + if (!(writeId == rhs.writeId)) + return false; + return true; + } + bool operator != (const HeartbeatWriteIdRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HeartbeatWriteIdRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HeartbeatWriteIdRequest &a, HeartbeatWriteIdRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const HeartbeatWriteIdRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class HeartbeatWriteIdResult { + public: + + HeartbeatWriteIdResult(const HeartbeatWriteIdResult&); + HeartbeatWriteIdResult& operator=(const HeartbeatWriteIdResult&); + HeartbeatWriteIdResult() { + } + + virtual ~HeartbeatWriteIdResult() throw(); + + bool operator == (const HeartbeatWriteIdResult & /* rhs */) const + { + return true; + } + bool operator != (const HeartbeatWriteIdResult &rhs) const { + return !(*this == rhs); + } + + bool operator < (const HeartbeatWriteIdResult & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(HeartbeatWriteIdResult &a, HeartbeatWriteIdResult &b); + +inline std::ostream& operator<<(std::ostream& out, const HeartbeatWriteIdResult& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _GetAllFunctionsResponse__isset { _GetAllFunctionsResponse__isset() : functions(false) {} bool functions :1;
