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/11/15 20:20:46 UTC
[14/50] [abbrv] hive git commit: HIVE-15062 : create backward compat
checking for metastore APIs (Sergey Shelukhin,
reviewed by Thejas M Nair and Sushanth Sowmyan)
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/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 525408b..1e1acaa 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
@@ -52,6 +52,8 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService
virtual void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) = 0;
virtual void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name) = 0;
virtual void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) = 0;
+ virtual void get_table_req(GetTableResult& _return, const GetTableRequest& req) = 0;
+ virtual void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) = 0;
virtual void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) = 0;
virtual void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) = 0;
virtual void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) = 0;
@@ -293,6 +295,12 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p
void get_table_objects_by_name(std::vector<Table> & /* _return */, const std::string& /* dbname */, const std::vector<std::string> & /* tbl_names */) {
return;
}
+ void get_table_req(GetTableResult& /* _return */, const GetTableRequest& /* req */) {
+ return;
+ }
+ void get_table_objects_by_name_req(GetTablesResult& /* _return */, const GetTablesRequest& /* req */) {
+ return;
+ }
void get_table_names_by_filter(std::vector<std::string> & /* _return */, const std::string& /* dbname */, const std::string& /* filter */, const int16_t /* max_tables */) {
return;
}
@@ -4310,11 +4318,8 @@ class ThriftHiveMetastore_get_table_objects_by_name_pargs {
};
typedef struct _ThriftHiveMetastore_get_table_objects_by_name_result__isset {
- _ThriftHiveMetastore_get_table_objects_by_name_result__isset() : success(false), o1(false), o2(false), o3(false) {}
+ _ThriftHiveMetastore_get_table_objects_by_name_result__isset() : success(false) {}
bool success :1;
- bool o1 :1;
- bool o2 :1;
- bool o3 :1;
} _ThriftHiveMetastore_get_table_objects_by_name_result__isset;
class ThriftHiveMetastore_get_table_objects_by_name_result {
@@ -4327,13 +4332,240 @@ class ThriftHiveMetastore_get_table_objects_by_name_result {
virtual ~ThriftHiveMetastore_get_table_objects_by_name_result() throw();
std::vector<Table> success;
+
+ _ThriftHiveMetastore_get_table_objects_by_name_result__isset __isset;
+
+ void __set_success(const std::vector<Table> & val);
+
+ bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_objects_by_name_presult__isset {
+ _ThriftHiveMetastore_get_table_objects_by_name_presult__isset() : success(false) {}
+ bool success :1;
+} _ThriftHiveMetastore_get_table_objects_by_name_presult__isset;
+
+class ThriftHiveMetastore_get_table_objects_by_name_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_objects_by_name_presult() throw();
+ std::vector<Table> * success;
+
+ _ThriftHiveMetastore_get_table_objects_by_name_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_req_args__isset {
+ _ThriftHiveMetastore_get_table_req_args__isset() : req(false) {}
+ bool req :1;
+} _ThriftHiveMetastore_get_table_req_args__isset;
+
+class ThriftHiveMetastore_get_table_req_args {
+ public:
+
+ ThriftHiveMetastore_get_table_req_args(const ThriftHiveMetastore_get_table_req_args&);
+ ThriftHiveMetastore_get_table_req_args& operator=(const ThriftHiveMetastore_get_table_req_args&);
+ ThriftHiveMetastore_get_table_req_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_req_args() throw();
+ GetTableRequest req;
+
+ _ThriftHiveMetastore_get_table_req_args__isset __isset;
+
+ void __set_req(const GetTableRequest& val);
+
+ bool operator == (const ThriftHiveMetastore_get_table_req_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_table_req_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_req_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_table_req_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_req_pargs() throw();
+ const GetTableRequest* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_req_result__isset {
+ _ThriftHiveMetastore_get_table_req_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_table_req_result__isset;
+
+class ThriftHiveMetastore_get_table_req_result {
+ public:
+
+ ThriftHiveMetastore_get_table_req_result(const ThriftHiveMetastore_get_table_req_result&);
+ ThriftHiveMetastore_get_table_req_result& operator=(const ThriftHiveMetastore_get_table_req_result&);
+ ThriftHiveMetastore_get_table_req_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_req_result() throw();
+ GetTableResult success;
+ MetaException o1;
+ NoSuchObjectException o2;
+
+ _ThriftHiveMetastore_get_table_req_result__isset __isset;
+
+ void __set_success(const GetTableResult& val);
+
+ void __set_o1(const MetaException& val);
+
+ void __set_o2(const NoSuchObjectException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_table_req_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_table_req_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_req_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_req_presult__isset {
+ _ThriftHiveMetastore_get_table_req_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_table_req_presult__isset;
+
+class ThriftHiveMetastore_get_table_req_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_req_presult() throw();
+ GetTableResult* success;
+ MetaException o1;
+ NoSuchObjectException o2;
+
+ _ThriftHiveMetastore_get_table_req_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset {
+ _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset() : req(false) {}
+ bool req :1;
+} _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset;
+
+class ThriftHiveMetastore_get_table_objects_by_name_req_args {
+ public:
+
+ ThriftHiveMetastore_get_table_objects_by_name_req_args(const ThriftHiveMetastore_get_table_objects_by_name_req_args&);
+ ThriftHiveMetastore_get_table_objects_by_name_req_args& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_args&);
+ ThriftHiveMetastore_get_table_objects_by_name_req_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_args() throw();
+ GetTablesRequest req;
+
+ _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset __isset;
+
+ void __set_req(const GetTablesRequest& val);
+
+ bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_req_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_req_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_req_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_table_objects_by_name_req_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_pargs() throw();
+ const GetTablesRequest* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset {
+ _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset() : success(false), o1(false), o2(false), o3(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset;
+
+class ThriftHiveMetastore_get_table_objects_by_name_req_result {
+ public:
+
+ ThriftHiveMetastore_get_table_objects_by_name_req_result(const ThriftHiveMetastore_get_table_objects_by_name_req_result&);
+ ThriftHiveMetastore_get_table_objects_by_name_req_result& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_result&);
+ ThriftHiveMetastore_get_table_objects_by_name_req_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_result() throw();
+ GetTablesResult success;
MetaException o1;
InvalidOperationException o2;
UnknownDBException o3;
- _ThriftHiveMetastore_get_table_objects_by_name_result__isset __isset;
+ _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset __isset;
- void __set_success(const std::vector<Table> & val);
+ void __set_success(const GetTablesResult& val);
void __set_o1(const MetaException& val);
@@ -4341,7 +4573,7 @@ class ThriftHiveMetastore_get_table_objects_by_name_result {
void __set_o3(const UnknownDBException& val);
- bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_result & rhs) const
+ bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_req_result & rhs) const
{
if (!(success == rhs.success))
return false;
@@ -4353,36 +4585,36 @@ class ThriftHiveMetastore_get_table_objects_by_name_result {
return false;
return true;
}
- bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_result &rhs) const {
+ bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_req_result &rhs) const {
return !(*this == rhs);
}
- bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_result & ) const;
+ bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_req_result & ) const;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
};
-typedef struct _ThriftHiveMetastore_get_table_objects_by_name_presult__isset {
- _ThriftHiveMetastore_get_table_objects_by_name_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
+typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset {
+ _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
bool success :1;
bool o1 :1;
bool o2 :1;
bool o3 :1;
-} _ThriftHiveMetastore_get_table_objects_by_name_presult__isset;
+} _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset;
-class ThriftHiveMetastore_get_table_objects_by_name_presult {
+class ThriftHiveMetastore_get_table_objects_by_name_req_presult {
public:
- virtual ~ThriftHiveMetastore_get_table_objects_by_name_presult() throw();
- std::vector<Table> * success;
+ virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_presult() throw();
+ GetTablesResult* success;
MetaException o1;
InvalidOperationException o2;
UnknownDBException o3;
- _ThriftHiveMetastore_get_table_objects_by_name_presult__isset __isset;
+ _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset __isset;
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
@@ -19362,6 +19594,12 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public
void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
void send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
void recv_get_table_objects_by_name(std::vector<Table> & _return);
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req);
+ void send_get_table_req(const GetTableRequest& req);
+ void recv_get_table_req(GetTableResult& _return);
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req);
+ void send_get_table_objects_by_name_req(const GetTablesRequest& req);
+ void recv_get_table_objects_by_name_req(GetTablesResult& _return);
void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables);
void recv_get_table_names_by_filter(std::vector<std::string> & _return);
@@ -19762,6 +20000,8 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP
void process_get_all_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_table_objects_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_get_table_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_get_table_objects_by_name_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_table_names_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_alter_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_alter_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -19916,6 +20156,8 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP
processMap_["get_all_tables"] = &ThriftHiveMetastoreProcessor::process_get_all_tables;
processMap_["get_table"] = &ThriftHiveMetastoreProcessor::process_get_table;
processMap_["get_table_objects_by_name"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name;
+ processMap_["get_table_req"] = &ThriftHiveMetastoreProcessor::process_get_table_req;
+ processMap_["get_table_objects_by_name_req"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name_req;
processMap_["get_table_names_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_table_names_by_filter;
processMap_["alter_table"] = &ThriftHiveMetastoreProcessor::process_alter_table;
processMap_["alter_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_environment_context;
@@ -20355,6 +20597,26 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi
return;
}
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->get_table_req(_return, req);
+ }
+ ifaces_[i]->get_table_req(_return, req);
+ return;
+ }
+
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->get_table_objects_by_name_req(_return, req);
+ }
+ ifaces_[i]->get_table_objects_by_name_req(_return, req);
+ return;
+ }
+
void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) {
size_t sz = ifaces_.size();
size_t i = 0;
@@ -21612,6 +21874,12 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf
void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
int32_t send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
void recv_get_table_objects_by_name(std::vector<Table> & _return, const int32_t seqid);
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req);
+ int32_t send_get_table_req(const GetTableRequest& req);
+ void recv_get_table_req(GetTableResult& _return, const int32_t seqid);
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req);
+ int32_t send_get_table_objects_by_name_req(const GetTablesRequest& req);
+ void recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid);
void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
int32_t send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables);
void recv_get_table_names_by_filter(std::vector<std::string> & _return, const int32_t seqid);
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/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 d66fdbe..7a3fa4b 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
@@ -172,6 +172,16 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf {
printf("get_table_objects_by_name\n");
}
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req) {
+ // Your implementation goes here
+ printf("get_table_req\n");
+ }
+
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) {
+ // Your implementation goes here
+ printf("get_table_objects_by_name_req\n");
+ }
+
void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) {
// Your implementation goes here
printf("get_table_names_by_filter\n");
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/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 f3aaf7e..974ddb5 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -177,6 +177,14 @@ const char* _kFileMetadataExprTypeNames[] = {
};
const std::map<int, const char*> _FileMetadataExprType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _kFileMetadataExprTypeValues, _kFileMetadataExprTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+int _kClientCapabilityValues[] = {
+ ClientCapability::TEST_CAPABILITY
+};
+const char* _kClientCapabilityNames[] = {
+ "TEST_CAPABILITY"
+};
+const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(1, _kClientCapabilityValues, _kClientCapabilityNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
Version::~Version() throw() {
}
@@ -17784,6 +17792,593 @@ void GetAllFunctionsResponse::printTo(std::ostream& out) const {
}
+ClientCapabilities::~ClientCapabilities() throw() {
+}
+
+
+void ClientCapabilities::__set_values(const std::vector<ClientCapability::type> & val) {
+ this->values = val;
+}
+
+uint32_t ClientCapabilities::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_values = 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_LIST) {
+ {
+ this->values.clear();
+ uint32_t _size747;
+ ::apache::thrift::protocol::TType _etype750;
+ xfer += iprot->readListBegin(_etype750, _size747);
+ this->values.resize(_size747);
+ uint32_t _i751;
+ for (_i751 = 0; _i751 < _size747; ++_i751)
+ {
+ int32_t ecast752;
+ xfer += iprot->readI32(ecast752);
+ this->values[_i751] = (ClientCapability::type)ecast752;
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ClientCapabilities");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
+ std::vector<ClientCapability::type> ::const_iterator _iter753;
+ for (_iter753 = this->values.begin(); _iter753 != this->values.end(); ++_iter753)
+ {
+ xfer += oprot->writeI32((int32_t)(*_iter753));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ClientCapabilities &a, ClientCapabilities &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+}
+
+ClientCapabilities::ClientCapabilities(const ClientCapabilities& other754) {
+ values = other754.values;
+}
+ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other755) {
+ values = other755.values;
+ return *this;
+}
+void ClientCapabilities::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "ClientCapabilities(";
+ out << "values=" << to_string(values);
+ out << ")";
+}
+
+
+GetTableRequest::~GetTableRequest() throw() {
+}
+
+
+void GetTableRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void GetTableRequest::__set_tblName(const std::string& val) {
+ this->tblName = val;
+}
+
+void GetTableRequest::__set_capabilities(const ClientCapabilities& val) {
+ this->capabilities = val;
+__isset.capabilities = true;
+}
+
+uint32_t GetTableRequest::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;
+
+ 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_STRUCT) {
+ xfer += this->capabilities.read(iprot);
+ this->__isset.capabilities = 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);
+ return xfer;
+}
+
+uint32_t GetTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTableRequest");
+
+ 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();
+
+ if (this->__isset.capabilities) {
+ xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->capabilities.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTableRequest &a, GetTableRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.capabilities, b.capabilities);
+ swap(a.__isset, b.__isset);
+}
+
+GetTableRequest::GetTableRequest(const GetTableRequest& other756) {
+ dbName = other756.dbName;
+ tblName = other756.tblName;
+ capabilities = other756.capabilities;
+ __isset = other756.__isset;
+}
+GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other757) {
+ dbName = other757.dbName;
+ tblName = other757.tblName;
+ capabilities = other757.capabilities;
+ __isset = other757.__isset;
+ return *this;
+}
+void GetTableRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTableRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblName=" << to_string(tblName);
+ out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ")";
+}
+
+
+GetTableResult::~GetTableResult() throw() {
+}
+
+
+void GetTableResult::__set_table(const Table& val) {
+ this->table = val;
+}
+
+uint32_t GetTableResult::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_table = 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_STRUCT) {
+ xfer += this->table.read(iprot);
+ isset_table = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_table)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t GetTableResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTableResult");
+
+ xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->table.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTableResult &a, GetTableResult &b) {
+ using ::std::swap;
+ swap(a.table, b.table);
+}
+
+GetTableResult::GetTableResult(const GetTableResult& other758) {
+ table = other758.table;
+}
+GetTableResult& GetTableResult::operator=(const GetTableResult& other759) {
+ table = other759.table;
+ return *this;
+}
+void GetTableResult::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTableResult(";
+ out << "table=" << to_string(table);
+ out << ")";
+}
+
+
+GetTablesRequest::~GetTablesRequest() throw() {
+}
+
+
+void GetTablesRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void GetTablesRequest::__set_tblNames(const std::vector<std::string> & val) {
+ this->tblNames = val;
+__isset.tblNames = true;
+}
+
+void GetTablesRequest::__set_capabilities(const ClientCapabilities& val) {
+ this->capabilities = val;
+__isset.capabilities = true;
+}
+
+uint32_t GetTablesRequest::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;
+
+ 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_LIST) {
+ {
+ this->tblNames.clear();
+ uint32_t _size760;
+ ::apache::thrift::protocol::TType _etype763;
+ xfer += iprot->readListBegin(_etype763, _size760);
+ this->tblNames.resize(_size760);
+ uint32_t _i764;
+ for (_i764 = 0; _i764 < _size760; ++_i764)
+ {
+ xfer += iprot->readString(this->tblNames[_i764]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.tblNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->capabilities.read(iprot);
+ this->__isset.capabilities = 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);
+ return xfer;
+}
+
+uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTablesRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.tblNames) {
+ xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tblNames.size()));
+ std::vector<std::string> ::const_iterator _iter765;
+ for (_iter765 = this->tblNames.begin(); _iter765 != this->tblNames.end(); ++_iter765)
+ {
+ xfer += oprot->writeString((*_iter765));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.capabilities) {
+ xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->capabilities.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTablesRequest &a, GetTablesRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblNames, b.tblNames);
+ swap(a.capabilities, b.capabilities);
+ swap(a.__isset, b.__isset);
+}
+
+GetTablesRequest::GetTablesRequest(const GetTablesRequest& other766) {
+ dbName = other766.dbName;
+ tblNames = other766.tblNames;
+ capabilities = other766.capabilities;
+ __isset = other766.__isset;
+}
+GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other767) {
+ dbName = other767.dbName;
+ tblNames = other767.tblNames;
+ capabilities = other767.capabilities;
+ __isset = other767.__isset;
+ return *this;
+}
+void GetTablesRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTablesRequest(";
+ out << "dbName=" << to_string(dbName);
+ out << ", " << "tblNames="; (__isset.tblNames ? (out << to_string(tblNames)) : (out << "<null>"));
+ out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
+ out << ")";
+}
+
+
+GetTablesResult::~GetTablesResult() throw() {
+}
+
+
+void GetTablesResult::__set_tables(const std::vector<Table> & val) {
+ this->tables = val;
+}
+
+uint32_t GetTablesResult::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_tables = 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_LIST) {
+ {
+ this->tables.clear();
+ uint32_t _size768;
+ ::apache::thrift::protocol::TType _etype771;
+ xfer += iprot->readListBegin(_etype771, _size768);
+ this->tables.resize(_size768);
+ uint32_t _i772;
+ for (_i772 = 0; _i772 < _size768; ++_i772)
+ {
+ xfer += this->tables[_i772].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_tables = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_tables)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("GetTablesResult");
+
+ xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tables.size()));
+ std::vector<Table> ::const_iterator _iter773;
+ for (_iter773 = this->tables.begin(); _iter773 != this->tables.end(); ++_iter773)
+ {
+ xfer += (*_iter773).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(GetTablesResult &a, GetTablesResult &b) {
+ using ::std::swap;
+ swap(a.tables, b.tables);
+}
+
+GetTablesResult::GetTablesResult(const GetTablesResult& other774) {
+ tables = other774.tables;
+}
+GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other775) {
+ tables = other775.tables;
+ return *this;
+}
+void GetTablesResult::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "GetTablesResult(";
+ out << "tables=" << to_string(tables);
+ out << ")";
+}
+
+
TableMeta::~TableMeta() throw() {
}
@@ -17915,19 +18510,19 @@ void swap(TableMeta &a, TableMeta &b) {
swap(a.__isset, b.__isset);
}
-TableMeta::TableMeta(const TableMeta& other747) {
- dbName = other747.dbName;
- tableName = other747.tableName;
- tableType = other747.tableType;
- comments = other747.comments;
- __isset = other747.__isset;
+TableMeta::TableMeta(const TableMeta& other776) {
+ dbName = other776.dbName;
+ tableName = other776.tableName;
+ tableType = other776.tableType;
+ comments = other776.comments;
+ __isset = other776.__isset;
}
-TableMeta& TableMeta::operator=(const TableMeta& other748) {
- dbName = other748.dbName;
- tableName = other748.tableName;
- tableType = other748.tableType;
- comments = other748.comments;
- __isset = other748.__isset;
+TableMeta& TableMeta::operator=(const TableMeta& other777) {
+ dbName = other777.dbName;
+ tableName = other777.tableName;
+ tableType = other777.tableType;
+ comments = other777.comments;
+ __isset = other777.__isset;
return *this;
}
void TableMeta::printTo(std::ostream& out) const {
@@ -18010,13 +18605,13 @@ void swap(MetaException &a, MetaException &b) {
swap(a.__isset, b.__isset);
}
-MetaException::MetaException(const MetaException& other749) : TException() {
- message = other749.message;
- __isset = other749.__isset;
+MetaException::MetaException(const MetaException& other778) : TException() {
+ message = other778.message;
+ __isset = other778.__isset;
}
-MetaException& MetaException::operator=(const MetaException& other750) {
- message = other750.message;
- __isset = other750.__isset;
+MetaException& MetaException::operator=(const MetaException& other779) {
+ message = other779.message;
+ __isset = other779.__isset;
return *this;
}
void MetaException::printTo(std::ostream& out) const {
@@ -18107,13 +18702,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& other780) : TException() {
+ message = other780.message;
+ __isset = other780.__isset;
}
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other752) {
- message = other752.message;
- __isset = other752.__isset;
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other781) {
+ message = other781.message;
+ __isset = other781.__isset;
return *this;
}
void UnknownTableException::printTo(std::ostream& out) const {
@@ -18204,13 +18799,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& other782) : TException() {
+ message = other782.message;
+ __isset = other782.__isset;
}
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other754) {
- message = other754.message;
- __isset = other754.__isset;
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other783) {
+ message = other783.message;
+ __isset = other783.__isset;
return *this;
}
void UnknownDBException::printTo(std::ostream& out) const {
@@ -18301,13 +18896,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& other784) : TException() {
+ message = other784.message;
+ __isset = other784.__isset;
}
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other756) {
- message = other756.message;
- __isset = other756.__isset;
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other785) {
+ message = other785.message;
+ __isset = other785.__isset;
return *this;
}
void AlreadyExistsException::printTo(std::ostream& out) const {
@@ -18398,13 +18993,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& other786) : TException() {
+ message = other786.message;
+ __isset = other786.__isset;
}
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other758) {
- message = other758.message;
- __isset = other758.__isset;
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other787) {
+ message = other787.message;
+ __isset = other787.__isset;
return *this;
}
void InvalidPartitionException::printTo(std::ostream& out) const {
@@ -18495,13 +19090,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& other788) : TException() {
+ message = other788.message;
+ __isset = other788.__isset;
}
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other760) {
- message = other760.message;
- __isset = other760.__isset;
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other789) {
+ message = other789.message;
+ __isset = other789.__isset;
return *this;
}
void UnknownPartitionException::printTo(std::ostream& out) const {
@@ -18592,13 +19187,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& other790) : TException() {
+ message = other790.message;
+ __isset = other790.__isset;
}
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other762) {
- message = other762.message;
- __isset = other762.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other791) {
+ message = other791.message;
+ __isset = other791.__isset;
return *this;
}
void InvalidObjectException::printTo(std::ostream& out) const {
@@ -18689,13 +19284,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& other792) : TException() {
+ message = other792.message;
+ __isset = other792.__isset;
}
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other764) {
- message = other764.message;
- __isset = other764.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other793) {
+ message = other793.message;
+ __isset = other793.__isset;
return *this;
}
void NoSuchObjectException::printTo(std::ostream& out) const {
@@ -18786,13 +19381,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& other794) : TException() {
+ message = other794.message;
+ __isset = other794.__isset;
}
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other766) {
- message = other766.message;
- __isset = other766.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other795) {
+ message = other795.message;
+ __isset = other795.__isset;
return *this;
}
void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@ -18883,13 +19478,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& other796) : TException() {
+ message = other796.message;
+ __isset = other796.__isset;
}
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other768) {
- message = other768.message;
- __isset = other768.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other797) {
+ message = other797.message;
+ __isset = other797.__isset;
return *this;
}
void InvalidOperationException::printTo(std::ostream& out) const {
@@ -18980,13 +19575,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& other798) : TException() {
+ message = other798.message;
+ __isset = other798.__isset;
}
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other770) {
- message = other770.message;
- __isset = other770.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other799) {
+ message = other799.message;
+ __isset = other799.__isset;
return *this;
}
void ConfigValSecurityException::printTo(std::ostream& out) const {
@@ -19077,13 +19672,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& other800) : TException() {
+ message = other800.message;
+ __isset = other800.__isset;
}
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other772) {
- message = other772.message;
- __isset = other772.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other801) {
+ message = other801.message;
+ __isset = other801.__isset;
return *this;
}
void InvalidInputException::printTo(std::ostream& out) const {
@@ -19174,13 +19769,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& other802) : TException() {
+ message = other802.message;
+ __isset = other802.__isset;
}
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other774) {
- message = other774.message;
- __isset = other774.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other803) {
+ message = other803.message;
+ __isset = other803.__isset;
return *this;
}
void NoSuchTxnException::printTo(std::ostream& out) const {
@@ -19271,13 +19866,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& other804) : TException() {
+ message = other804.message;
+ __isset = other804.__isset;
}
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other776) {
- message = other776.message;
- __isset = other776.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other805) {
+ message = other805.message;
+ __isset = other805.__isset;
return *this;
}
void TxnAbortedException::printTo(std::ostream& out) const {
@@ -19368,13 +19963,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& other806) : TException() {
+ message = other806.message;
+ __isset = other806.__isset;
}
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other778) {
- message = other778.message;
- __isset = other778.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other807) {
+ message = other807.message;
+ __isset = other807.__isset;
return *this;
}
void TxnOpenException::printTo(std::ostream& out) const {
@@ -19465,13 +20060,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& other808) : TException() {
+ message = other808.message;
+ __isset = other808.__isset;
}
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other780) {
- message = other780.message;
- __isset = other780.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other809) {
+ message = other809.message;
+ __isset = other809.__isset;
return *this;
}
void NoSuchLockException::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/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 1252a2d..70fe2c3 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -158,6 +158,14 @@ struct FileMetadataExprType {
extern const std::map<int, const char*> _FileMetadataExprType_VALUES_TO_NAMES;
+struct ClientCapability {
+ enum type {
+ TEST_CAPABILITY = 1
+ };
+};
+
+extern const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES;
+
class Version;
class FieldSchema;
@@ -386,6 +394,16 @@ class CacheFileMetadataRequest;
class GetAllFunctionsResponse;
+class ClientCapabilities;
+
+class GetTableRequest;
+
+class GetTableResult;
+
+class GetTablesRequest;
+
+class GetTablesResult;
+
class TableMeta;
class MetaException;
@@ -7229,6 +7247,245 @@ inline std::ostream& operator<<(std::ostream& out, const GetAllFunctionsResponse
return out;
}
+
+class ClientCapabilities {
+ public:
+
+ ClientCapabilities(const ClientCapabilities&);
+ ClientCapabilities& operator=(const ClientCapabilities&);
+ ClientCapabilities() {
+ }
+
+ virtual ~ClientCapabilities() throw();
+ std::vector<ClientCapability::type> values;
+
+ void __set_values(const std::vector<ClientCapability::type> & val);
+
+ bool operator == (const ClientCapabilities & rhs) const
+ {
+ if (!(values == rhs.values))
+ return false;
+ return true;
+ }
+ bool operator != (const ClientCapabilities &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ClientCapabilities & ) 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(ClientCapabilities &a, ClientCapabilities &b);
+
+inline std::ostream& operator<<(std::ostream& out, const ClientCapabilities& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _GetTableRequest__isset {
+ _GetTableRequest__isset() : capabilities(false) {}
+ bool capabilities :1;
+} _GetTableRequest__isset;
+
+class GetTableRequest {
+ public:
+
+ GetTableRequest(const GetTableRequest&);
+ GetTableRequest& operator=(const GetTableRequest&);
+ GetTableRequest() : dbName(), tblName() {
+ }
+
+ virtual ~GetTableRequest() throw();
+ std::string dbName;
+ std::string tblName;
+ ClientCapabilities capabilities;
+
+ _GetTableRequest__isset __isset;
+
+ void __set_dbName(const std::string& val);
+
+ void __set_tblName(const std::string& val);
+
+ void __set_capabilities(const ClientCapabilities& val);
+
+ bool operator == (const GetTableRequest & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tblName == rhs.tblName))
+ return false;
+ if (__isset.capabilities != rhs.__isset.capabilities)
+ return false;
+ else if (__isset.capabilities && !(capabilities == rhs.capabilities))
+ return false;
+ return true;
+ }
+ bool operator != (const GetTableRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetTableRequest & ) 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(GetTableRequest &a, GetTableRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetTableRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class GetTableResult {
+ public:
+
+ GetTableResult(const GetTableResult&);
+ GetTableResult& operator=(const GetTableResult&);
+ GetTableResult() {
+ }
+
+ virtual ~GetTableResult() throw();
+ Table table;
+
+ void __set_table(const Table& val);
+
+ bool operator == (const GetTableResult & rhs) const
+ {
+ if (!(table == rhs.table))
+ return false;
+ return true;
+ }
+ bool operator != (const GetTableResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetTableResult & ) 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(GetTableResult &a, GetTableResult &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetTableResult& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _GetTablesRequest__isset {
+ _GetTablesRequest__isset() : tblNames(false), capabilities(false) {}
+ bool tblNames :1;
+ bool capabilities :1;
+} _GetTablesRequest__isset;
+
+class GetTablesRequest {
+ public:
+
+ GetTablesRequest(const GetTablesRequest&);
+ GetTablesRequest& operator=(const GetTablesRequest&);
+ GetTablesRequest() : dbName() {
+ }
+
+ virtual ~GetTablesRequest() throw();
+ std::string dbName;
+ std::vector<std::string> tblNames;
+ ClientCapabilities capabilities;
+
+ _GetTablesRequest__isset __isset;
+
+ void __set_dbName(const std::string& val);
+
+ void __set_tblNames(const std::vector<std::string> & val);
+
+ void __set_capabilities(const ClientCapabilities& val);
+
+ bool operator == (const GetTablesRequest & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (__isset.tblNames != rhs.__isset.tblNames)
+ return false;
+ else if (__isset.tblNames && !(tblNames == rhs.tblNames))
+ return false;
+ if (__isset.capabilities != rhs.__isset.capabilities)
+ return false;
+ else if (__isset.capabilities && !(capabilities == rhs.capabilities))
+ return false;
+ return true;
+ }
+ bool operator != (const GetTablesRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetTablesRequest & ) 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(GetTablesRequest &a, GetTablesRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetTablesRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class GetTablesResult {
+ public:
+
+ GetTablesResult(const GetTablesResult&);
+ GetTablesResult& operator=(const GetTablesResult&);
+ GetTablesResult() {
+ }
+
+ virtual ~GetTablesResult() throw();
+ std::vector<Table> tables;
+
+ void __set_tables(const std::vector<Table> & val);
+
+ bool operator == (const GetTablesResult & rhs) const
+ {
+ if (!(tables == rhs.tables))
+ return false;
+ return true;
+ }
+ bool operator != (const GetTablesResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const GetTablesResult & ) 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(GetTablesResult &a, GetTablesResult &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetTablesResult& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
typedef struct _TableMeta__isset {
_TableMeta__isset() : comments(false) {}
bool comments :1;
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
new file mode 100644
index 0000000..5fc7d56
--- /dev/null
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
@@ -0,0 +1,441 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class ClientCapabilities implements org.apache.thrift.TBase<ClientCapabilities, ClientCapabilities._Fields>, java.io.Serializable, Cloneable, Comparable<ClientCapabilities> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ClientCapabilities");
+
+ private static final org.apache.thrift.protocol.TField VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.LIST, (short)1);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new ClientCapabilitiesStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new ClientCapabilitiesTupleSchemeFactory());
+ }
+
+ private List<ClientCapability> values; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ VALUES((short)1, "values");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // VALUES
+ return VALUES;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, ClientCapability.class))));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ClientCapabilities.class, metaDataMap);
+ }
+
+ public ClientCapabilities() {
+ }
+
+ public ClientCapabilities(
+ List<ClientCapability> values)
+ {
+ this();
+ this.values = values;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public ClientCapabilities(ClientCapabilities other) {
+ if (other.isSetValues()) {
+ List<ClientCapability> __this__values = new ArrayList<ClientCapability>(other.values.size());
+ for (ClientCapability other_element : other.values) {
+ __this__values.add(other_element);
+ }
+ this.values = __this__values;
+ }
+ }
+
+ public ClientCapabilities deepCopy() {
+ return new ClientCapabilities(this);
+ }
+
+ @Override
+ public void clear() {
+ this.values = null;
+ }
+
+ public int getValuesSize() {
+ return (this.values == null) ? 0 : this.values.size();
+ }
+
+ public java.util.Iterator<ClientCapability> getValuesIterator() {
+ return (this.values == null) ? null : this.values.iterator();
+ }
+
+ public void addToValues(ClientCapability elem) {
+ if (this.values == null) {
+ this.values = new ArrayList<ClientCapability>();
+ }
+ this.values.add(elem);
+ }
+
+ public List<ClientCapability> getValues() {
+ return this.values;
+ }
+
+ public void setValues(List<ClientCapability> values) {
+ this.values = values;
+ }
+
+ public void unsetValues() {
+ this.values = null;
+ }
+
+ /** Returns true if field values is set (has been assigned a value) and false otherwise */
+ public boolean isSetValues() {
+ return this.values != null;
+ }
+
+ public void setValuesIsSet(boolean value) {
+ if (!value) {
+ this.values = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case VALUES:
+ if (value == null) {
+ unsetValues();
+ } else {
+ setValues((List<ClientCapability>)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case VALUES:
+ return getValues();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case VALUES:
+ return isSetValues();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof ClientCapabilities)
+ return this.equals((ClientCapabilities)that);
+ return false;
+ }
+
+ public boolean equals(ClientCapabilities that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_values = true && this.isSetValues();
+ boolean that_present_values = true && that.isSetValues();
+ if (this_present_values || that_present_values) {
+ if (!(this_present_values && that_present_values))
+ return false;
+ if (!this.values.equals(that.values))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_values = true && (isSetValues());
+ list.add(present_values);
+ if (present_values)
+ list.add(values);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(ClientCapabilities other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetValues()).compareTo(other.isSetValues());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetValues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, other.values);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("ClientCapabilities(");
+ boolean first = true;
+
+ sb.append("values:");
+ if (this.values == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.values);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetValues()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'values' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class ClientCapabilitiesStandardSchemeFactory implements SchemeFactory {
+ public ClientCapabilitiesStandardScheme getScheme() {
+ return new ClientCapabilitiesStandardScheme();
+ }
+ }
+
+ private static class ClientCapabilitiesStandardScheme extends StandardScheme<ClientCapabilities> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, ClientCapabilities struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // VALUES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list642 = iprot.readListBegin();
+ struct.values = new ArrayList<ClientCapability>(_list642.size);
+ ClientCapability _elem643;
+ for (int _i644 = 0; _i644 < _list642.size; ++_i644)
+ {
+ _elem643 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
+ struct.values.add(_elem643);
+ }
+ iprot.readListEnd();
+ }
+ struct.setValuesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, ClientCapabilities struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.values != null) {
+ oprot.writeFieldBegin(VALUES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.values.size()));
+ for (ClientCapability _iter645 : struct.values)
+ {
+ oprot.writeI32(_iter645.getValue());
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class ClientCapabilitiesTupleSchemeFactory implements SchemeFactory {
+ public ClientCapabilitiesTupleScheme getScheme() {
+ return new ClientCapabilitiesTupleScheme();
+ }
+ }
+
+ private static class ClientCapabilitiesTupleScheme extends TupleScheme<ClientCapabilities> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ {
+ oprot.writeI32(struct.values.size());
+ for (ClientCapability _iter646 : struct.values)
+ {
+ oprot.writeI32(_iter646.getValue());
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ {
+ org.apache.thrift.protocol.TList _list647 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
+ struct.values = new ArrayList<ClientCapability>(_list647.size);
+ ClientCapability _elem648;
+ for (int _i649 = 0; _i649 < _list647.size; ++_i649)
+ {
+ _elem648 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
+ struct.values.add(_elem648);
+ }
+ }
+ struct.setValuesIsSet(true);
+ }
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/fb5bf0cb/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapability.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapability.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapability.java
new file mode 100644
index 0000000..f53bd82
--- /dev/null
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapability.java
@@ -0,0 +1,42 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+
+import java.util.Map;
+import java.util.HashMap;
+import org.apache.thrift.TEnum;
+
+public enum ClientCapability implements org.apache.thrift.TEnum {
+ TEST_CAPABILITY(1);
+
+ private final int value;
+
+ private ClientCapability(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ public static ClientCapability findByValue(int value) {
+ switch (value) {
+ case 1:
+ return TEST_CAPABILITY;
+ default:
+ return null;
+ }
+ }
+}