You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2016/09/08 01:52:56 UTC
[36/38] hive git commit: HIVE-14637 : edit or split MoveTask to
commit job results to metastore (Sergey Shelukhin)
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;