hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From vgumas...@apache.org
Subject [49/51] [partial] hive git commit: HIVE-12442: Refactor/repackage HiveServer2's Thrift code so that it can be used in the tasks (Rohit Dholakia reviewed by Vaibhav Gumashta)
Date Mon, 11 Jan 2016 08:26:32 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/3a1c4b57/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
new file mode 100644
index 0000000..3407564
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
@@ -0,0 +1,2564 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef TCLIService_H
+#define TCLIService_H
+
+#include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
+#include "TCLIService_types.h"
+
+namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift {
+
+#ifdef _WIN32
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
+class TCLIServiceIf {
+ public:
+  virtual ~TCLIServiceIf() {}
+  virtual void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) = 0;
+  virtual void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) = 0;
+  virtual void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) = 0;
+  virtual void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) = 0;
+  virtual void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) = 0;
+  virtual void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) = 0;
+  virtual void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) = 0;
+  virtual void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) = 0;
+  virtual void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) = 0;
+  virtual void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) = 0;
+  virtual void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) = 0;
+  virtual void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) = 0;
+  virtual void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) = 0;
+  virtual void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) = 0;
+  virtual void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) = 0;
+  virtual void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) = 0;
+  virtual void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) = 0;
+  virtual void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) = 0;
+  virtual void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) = 0;
+};
+
+class TCLIServiceIfFactory {
+ public:
+  typedef TCLIServiceIf Handler;
+
+  virtual ~TCLIServiceIfFactory() {}
+
+  virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(TCLIServiceIf* /* handler */) = 0;
+};
+
+class TCLIServiceIfSingletonFactory : virtual public TCLIServiceIfFactory {
+ public:
+  TCLIServiceIfSingletonFactory(const boost::shared_ptr<TCLIServiceIf>& iface) : iface_(iface) {}
+  virtual ~TCLIServiceIfSingletonFactory() {}
+
+  virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(TCLIServiceIf* /* handler */) {}
+
+ protected:
+  boost::shared_ptr<TCLIServiceIf> iface_;
+};
+
+class TCLIServiceNull : virtual public TCLIServiceIf {
+ public:
+  virtual ~TCLIServiceNull() {}
+  void OpenSession(TOpenSessionResp& /* _return */, const TOpenSessionReq& /* req */) {
+    return;
+  }
+  void CloseSession(TCloseSessionResp& /* _return */, const TCloseSessionReq& /* req */) {
+    return;
+  }
+  void GetInfo(TGetInfoResp& /* _return */, const TGetInfoReq& /* req */) {
+    return;
+  }
+  void ExecuteStatement(TExecuteStatementResp& /* _return */, const TExecuteStatementReq& /* req */) {
+    return;
+  }
+  void GetTypeInfo(TGetTypeInfoResp& /* _return */, const TGetTypeInfoReq& /* req */) {
+    return;
+  }
+  void GetCatalogs(TGetCatalogsResp& /* _return */, const TGetCatalogsReq& /* req */) {
+    return;
+  }
+  void GetSchemas(TGetSchemasResp& /* _return */, const TGetSchemasReq& /* req */) {
+    return;
+  }
+  void GetTables(TGetTablesResp& /* _return */, const TGetTablesReq& /* req */) {
+    return;
+  }
+  void GetTableTypes(TGetTableTypesResp& /* _return */, const TGetTableTypesReq& /* req */) {
+    return;
+  }
+  void GetColumns(TGetColumnsResp& /* _return */, const TGetColumnsReq& /* req */) {
+    return;
+  }
+  void GetFunctions(TGetFunctionsResp& /* _return */, const TGetFunctionsReq& /* req */) {
+    return;
+  }
+  void GetOperationStatus(TGetOperationStatusResp& /* _return */, const TGetOperationStatusReq& /* req */) {
+    return;
+  }
+  void CancelOperation(TCancelOperationResp& /* _return */, const TCancelOperationReq& /* req */) {
+    return;
+  }
+  void CloseOperation(TCloseOperationResp& /* _return */, const TCloseOperationReq& /* req */) {
+    return;
+  }
+  void GetResultSetMetadata(TGetResultSetMetadataResp& /* _return */, const TGetResultSetMetadataReq& /* req */) {
+    return;
+  }
+  void FetchResults(TFetchResultsResp& /* _return */, const TFetchResultsReq& /* req */) {
+    return;
+  }
+  void GetDelegationToken(TGetDelegationTokenResp& /* _return */, const TGetDelegationTokenReq& /* req */) {
+    return;
+  }
+  void CancelDelegationToken(TCancelDelegationTokenResp& /* _return */, const TCancelDelegationTokenReq& /* req */) {
+    return;
+  }
+  void RenewDelegationToken(TRenewDelegationTokenResp& /* _return */, const TRenewDelegationTokenReq& /* req */) {
+    return;
+  }
+};
+
+typedef struct _TCLIService_OpenSession_args__isset {
+  _TCLIService_OpenSession_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_OpenSession_args__isset;
+
+class TCLIService_OpenSession_args {
+ public:
+
+  TCLIService_OpenSession_args(const TCLIService_OpenSession_args&);
+  TCLIService_OpenSession_args& operator=(const TCLIService_OpenSession_args&);
+  TCLIService_OpenSession_args() {
+  }
+
+  virtual ~TCLIService_OpenSession_args() throw();
+  TOpenSessionReq req;
+
+  _TCLIService_OpenSession_args__isset __isset;
+
+  void __set_req(const TOpenSessionReq& val);
+
+  bool operator == (const TCLIService_OpenSession_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_OpenSession_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_OpenSession_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_OpenSession_pargs {
+ public:
+
+
+  virtual ~TCLIService_OpenSession_pargs() throw();
+  const TOpenSessionReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_OpenSession_result__isset {
+  _TCLIService_OpenSession_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_OpenSession_result__isset;
+
+class TCLIService_OpenSession_result {
+ public:
+
+  TCLIService_OpenSession_result(const TCLIService_OpenSession_result&);
+  TCLIService_OpenSession_result& operator=(const TCLIService_OpenSession_result&);
+  TCLIService_OpenSession_result() {
+  }
+
+  virtual ~TCLIService_OpenSession_result() throw();
+  TOpenSessionResp success;
+
+  _TCLIService_OpenSession_result__isset __isset;
+
+  void __set_success(const TOpenSessionResp& val);
+
+  bool operator == (const TCLIService_OpenSession_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_OpenSession_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_OpenSession_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_OpenSession_presult__isset {
+  _TCLIService_OpenSession_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_OpenSession_presult__isset;
+
+class TCLIService_OpenSession_presult {
+ public:
+
+
+  virtual ~TCLIService_OpenSession_presult() throw();
+  TOpenSessionResp* success;
+
+  _TCLIService_OpenSession_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_CloseSession_args__isset {
+  _TCLIService_CloseSession_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_CloseSession_args__isset;
+
+class TCLIService_CloseSession_args {
+ public:
+
+  TCLIService_CloseSession_args(const TCLIService_CloseSession_args&);
+  TCLIService_CloseSession_args& operator=(const TCLIService_CloseSession_args&);
+  TCLIService_CloseSession_args() {
+  }
+
+  virtual ~TCLIService_CloseSession_args() throw();
+  TCloseSessionReq req;
+
+  _TCLIService_CloseSession_args__isset __isset;
+
+  void __set_req(const TCloseSessionReq& val);
+
+  bool operator == (const TCLIService_CloseSession_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CloseSession_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CloseSession_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_CloseSession_pargs {
+ public:
+
+
+  virtual ~TCLIService_CloseSession_pargs() throw();
+  const TCloseSessionReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CloseSession_result__isset {
+  _TCLIService_CloseSession_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CloseSession_result__isset;
+
+class TCLIService_CloseSession_result {
+ public:
+
+  TCLIService_CloseSession_result(const TCLIService_CloseSession_result&);
+  TCLIService_CloseSession_result& operator=(const TCLIService_CloseSession_result&);
+  TCLIService_CloseSession_result() {
+  }
+
+  virtual ~TCLIService_CloseSession_result() throw();
+  TCloseSessionResp success;
+
+  _TCLIService_CloseSession_result__isset __isset;
+
+  void __set_success(const TCloseSessionResp& val);
+
+  bool operator == (const TCLIService_CloseSession_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CloseSession_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CloseSession_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CloseSession_presult__isset {
+  _TCLIService_CloseSession_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CloseSession_presult__isset;
+
+class TCLIService_CloseSession_presult {
+ public:
+
+
+  virtual ~TCLIService_CloseSession_presult() throw();
+  TCloseSessionResp* success;
+
+  _TCLIService_CloseSession_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetInfo_args__isset {
+  _TCLIService_GetInfo_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetInfo_args__isset;
+
+class TCLIService_GetInfo_args {
+ public:
+
+  TCLIService_GetInfo_args(const TCLIService_GetInfo_args&);
+  TCLIService_GetInfo_args& operator=(const TCLIService_GetInfo_args&);
+  TCLIService_GetInfo_args() {
+  }
+
+  virtual ~TCLIService_GetInfo_args() throw();
+  TGetInfoReq req;
+
+  _TCLIService_GetInfo_args__isset __isset;
+
+  void __set_req(const TGetInfoReq& val);
+
+  bool operator == (const TCLIService_GetInfo_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetInfo_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetInfo_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetInfo_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetInfo_pargs() throw();
+  const TGetInfoReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetInfo_result__isset {
+  _TCLIService_GetInfo_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetInfo_result__isset;
+
+class TCLIService_GetInfo_result {
+ public:
+
+  TCLIService_GetInfo_result(const TCLIService_GetInfo_result&);
+  TCLIService_GetInfo_result& operator=(const TCLIService_GetInfo_result&);
+  TCLIService_GetInfo_result() {
+  }
+
+  virtual ~TCLIService_GetInfo_result() throw();
+  TGetInfoResp success;
+
+  _TCLIService_GetInfo_result__isset __isset;
+
+  void __set_success(const TGetInfoResp& val);
+
+  bool operator == (const TCLIService_GetInfo_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetInfo_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetInfo_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetInfo_presult__isset {
+  _TCLIService_GetInfo_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetInfo_presult__isset;
+
+class TCLIService_GetInfo_presult {
+ public:
+
+
+  virtual ~TCLIService_GetInfo_presult() throw();
+  TGetInfoResp* success;
+
+  _TCLIService_GetInfo_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_ExecuteStatement_args__isset {
+  _TCLIService_ExecuteStatement_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_ExecuteStatement_args__isset;
+
+class TCLIService_ExecuteStatement_args {
+ public:
+
+  TCLIService_ExecuteStatement_args(const TCLIService_ExecuteStatement_args&);
+  TCLIService_ExecuteStatement_args& operator=(const TCLIService_ExecuteStatement_args&);
+  TCLIService_ExecuteStatement_args() {
+  }
+
+  virtual ~TCLIService_ExecuteStatement_args() throw();
+  TExecuteStatementReq req;
+
+  _TCLIService_ExecuteStatement_args__isset __isset;
+
+  void __set_req(const TExecuteStatementReq& val);
+
+  bool operator == (const TCLIService_ExecuteStatement_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_ExecuteStatement_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_ExecuteStatement_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_ExecuteStatement_pargs {
+ public:
+
+
+  virtual ~TCLIService_ExecuteStatement_pargs() throw();
+  const TExecuteStatementReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_ExecuteStatement_result__isset {
+  _TCLIService_ExecuteStatement_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_ExecuteStatement_result__isset;
+
+class TCLIService_ExecuteStatement_result {
+ public:
+
+  TCLIService_ExecuteStatement_result(const TCLIService_ExecuteStatement_result&);
+  TCLIService_ExecuteStatement_result& operator=(const TCLIService_ExecuteStatement_result&);
+  TCLIService_ExecuteStatement_result() {
+  }
+
+  virtual ~TCLIService_ExecuteStatement_result() throw();
+  TExecuteStatementResp success;
+
+  _TCLIService_ExecuteStatement_result__isset __isset;
+
+  void __set_success(const TExecuteStatementResp& val);
+
+  bool operator == (const TCLIService_ExecuteStatement_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_ExecuteStatement_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_ExecuteStatement_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_ExecuteStatement_presult__isset {
+  _TCLIService_ExecuteStatement_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_ExecuteStatement_presult__isset;
+
+class TCLIService_ExecuteStatement_presult {
+ public:
+
+
+  virtual ~TCLIService_ExecuteStatement_presult() throw();
+  TExecuteStatementResp* success;
+
+  _TCLIService_ExecuteStatement_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetTypeInfo_args__isset {
+  _TCLIService_GetTypeInfo_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetTypeInfo_args__isset;
+
+class TCLIService_GetTypeInfo_args {
+ public:
+
+  TCLIService_GetTypeInfo_args(const TCLIService_GetTypeInfo_args&);
+  TCLIService_GetTypeInfo_args& operator=(const TCLIService_GetTypeInfo_args&);
+  TCLIService_GetTypeInfo_args() {
+  }
+
+  virtual ~TCLIService_GetTypeInfo_args() throw();
+  TGetTypeInfoReq req;
+
+  _TCLIService_GetTypeInfo_args__isset __isset;
+
+  void __set_req(const TGetTypeInfoReq& val);
+
+  bool operator == (const TCLIService_GetTypeInfo_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTypeInfo_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTypeInfo_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetTypeInfo_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetTypeInfo_pargs() throw();
+  const TGetTypeInfoReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTypeInfo_result__isset {
+  _TCLIService_GetTypeInfo_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTypeInfo_result__isset;
+
+class TCLIService_GetTypeInfo_result {
+ public:
+
+  TCLIService_GetTypeInfo_result(const TCLIService_GetTypeInfo_result&);
+  TCLIService_GetTypeInfo_result& operator=(const TCLIService_GetTypeInfo_result&);
+  TCLIService_GetTypeInfo_result() {
+  }
+
+  virtual ~TCLIService_GetTypeInfo_result() throw();
+  TGetTypeInfoResp success;
+
+  _TCLIService_GetTypeInfo_result__isset __isset;
+
+  void __set_success(const TGetTypeInfoResp& val);
+
+  bool operator == (const TCLIService_GetTypeInfo_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTypeInfo_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTypeInfo_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTypeInfo_presult__isset {
+  _TCLIService_GetTypeInfo_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTypeInfo_presult__isset;
+
+class TCLIService_GetTypeInfo_presult {
+ public:
+
+
+  virtual ~TCLIService_GetTypeInfo_presult() throw();
+  TGetTypeInfoResp* success;
+
+  _TCLIService_GetTypeInfo_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetCatalogs_args__isset {
+  _TCLIService_GetCatalogs_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetCatalogs_args__isset;
+
+class TCLIService_GetCatalogs_args {
+ public:
+
+  TCLIService_GetCatalogs_args(const TCLIService_GetCatalogs_args&);
+  TCLIService_GetCatalogs_args& operator=(const TCLIService_GetCatalogs_args&);
+  TCLIService_GetCatalogs_args() {
+  }
+
+  virtual ~TCLIService_GetCatalogs_args() throw();
+  TGetCatalogsReq req;
+
+  _TCLIService_GetCatalogs_args__isset __isset;
+
+  void __set_req(const TGetCatalogsReq& val);
+
+  bool operator == (const TCLIService_GetCatalogs_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetCatalogs_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetCatalogs_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetCatalogs_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetCatalogs_pargs() throw();
+  const TGetCatalogsReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetCatalogs_result__isset {
+  _TCLIService_GetCatalogs_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetCatalogs_result__isset;
+
+class TCLIService_GetCatalogs_result {
+ public:
+
+  TCLIService_GetCatalogs_result(const TCLIService_GetCatalogs_result&);
+  TCLIService_GetCatalogs_result& operator=(const TCLIService_GetCatalogs_result&);
+  TCLIService_GetCatalogs_result() {
+  }
+
+  virtual ~TCLIService_GetCatalogs_result() throw();
+  TGetCatalogsResp success;
+
+  _TCLIService_GetCatalogs_result__isset __isset;
+
+  void __set_success(const TGetCatalogsResp& val);
+
+  bool operator == (const TCLIService_GetCatalogs_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetCatalogs_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetCatalogs_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetCatalogs_presult__isset {
+  _TCLIService_GetCatalogs_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetCatalogs_presult__isset;
+
+class TCLIService_GetCatalogs_presult {
+ public:
+
+
+  virtual ~TCLIService_GetCatalogs_presult() throw();
+  TGetCatalogsResp* success;
+
+  _TCLIService_GetCatalogs_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetSchemas_args__isset {
+  _TCLIService_GetSchemas_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetSchemas_args__isset;
+
+class TCLIService_GetSchemas_args {
+ public:
+
+  TCLIService_GetSchemas_args(const TCLIService_GetSchemas_args&);
+  TCLIService_GetSchemas_args& operator=(const TCLIService_GetSchemas_args&);
+  TCLIService_GetSchemas_args() {
+  }
+
+  virtual ~TCLIService_GetSchemas_args() throw();
+  TGetSchemasReq req;
+
+  _TCLIService_GetSchemas_args__isset __isset;
+
+  void __set_req(const TGetSchemasReq& val);
+
+  bool operator == (const TCLIService_GetSchemas_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetSchemas_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetSchemas_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetSchemas_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetSchemas_pargs() throw();
+  const TGetSchemasReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetSchemas_result__isset {
+  _TCLIService_GetSchemas_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetSchemas_result__isset;
+
+class TCLIService_GetSchemas_result {
+ public:
+
+  TCLIService_GetSchemas_result(const TCLIService_GetSchemas_result&);
+  TCLIService_GetSchemas_result& operator=(const TCLIService_GetSchemas_result&);
+  TCLIService_GetSchemas_result() {
+  }
+
+  virtual ~TCLIService_GetSchemas_result() throw();
+  TGetSchemasResp success;
+
+  _TCLIService_GetSchemas_result__isset __isset;
+
+  void __set_success(const TGetSchemasResp& val);
+
+  bool operator == (const TCLIService_GetSchemas_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetSchemas_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetSchemas_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetSchemas_presult__isset {
+  _TCLIService_GetSchemas_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetSchemas_presult__isset;
+
+class TCLIService_GetSchemas_presult {
+ public:
+
+
+  virtual ~TCLIService_GetSchemas_presult() throw();
+  TGetSchemasResp* success;
+
+  _TCLIService_GetSchemas_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetTables_args__isset {
+  _TCLIService_GetTables_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetTables_args__isset;
+
+class TCLIService_GetTables_args {
+ public:
+
+  TCLIService_GetTables_args(const TCLIService_GetTables_args&);
+  TCLIService_GetTables_args& operator=(const TCLIService_GetTables_args&);
+  TCLIService_GetTables_args() {
+  }
+
+  virtual ~TCLIService_GetTables_args() throw();
+  TGetTablesReq req;
+
+  _TCLIService_GetTables_args__isset __isset;
+
+  void __set_req(const TGetTablesReq& val);
+
+  bool operator == (const TCLIService_GetTables_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTables_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTables_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetTables_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetTables_pargs() throw();
+  const TGetTablesReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTables_result__isset {
+  _TCLIService_GetTables_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTables_result__isset;
+
+class TCLIService_GetTables_result {
+ public:
+
+  TCLIService_GetTables_result(const TCLIService_GetTables_result&);
+  TCLIService_GetTables_result& operator=(const TCLIService_GetTables_result&);
+  TCLIService_GetTables_result() {
+  }
+
+  virtual ~TCLIService_GetTables_result() throw();
+  TGetTablesResp success;
+
+  _TCLIService_GetTables_result__isset __isset;
+
+  void __set_success(const TGetTablesResp& val);
+
+  bool operator == (const TCLIService_GetTables_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTables_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTables_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTables_presult__isset {
+  _TCLIService_GetTables_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTables_presult__isset;
+
+class TCLIService_GetTables_presult {
+ public:
+
+
+  virtual ~TCLIService_GetTables_presult() throw();
+  TGetTablesResp* success;
+
+  _TCLIService_GetTables_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetTableTypes_args__isset {
+  _TCLIService_GetTableTypes_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetTableTypes_args__isset;
+
+class TCLIService_GetTableTypes_args {
+ public:
+
+  TCLIService_GetTableTypes_args(const TCLIService_GetTableTypes_args&);
+  TCLIService_GetTableTypes_args& operator=(const TCLIService_GetTableTypes_args&);
+  TCLIService_GetTableTypes_args() {
+  }
+
+  virtual ~TCLIService_GetTableTypes_args() throw();
+  TGetTableTypesReq req;
+
+  _TCLIService_GetTableTypes_args__isset __isset;
+
+  void __set_req(const TGetTableTypesReq& val);
+
+  bool operator == (const TCLIService_GetTableTypes_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTableTypes_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTableTypes_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetTableTypes_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetTableTypes_pargs() throw();
+  const TGetTableTypesReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTableTypes_result__isset {
+  _TCLIService_GetTableTypes_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTableTypes_result__isset;
+
+class TCLIService_GetTableTypes_result {
+ public:
+
+  TCLIService_GetTableTypes_result(const TCLIService_GetTableTypes_result&);
+  TCLIService_GetTableTypes_result& operator=(const TCLIService_GetTableTypes_result&);
+  TCLIService_GetTableTypes_result() {
+  }
+
+  virtual ~TCLIService_GetTableTypes_result() throw();
+  TGetTableTypesResp success;
+
+  _TCLIService_GetTableTypes_result__isset __isset;
+
+  void __set_success(const TGetTableTypesResp& val);
+
+  bool operator == (const TCLIService_GetTableTypes_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetTableTypes_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetTableTypes_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetTableTypes_presult__isset {
+  _TCLIService_GetTableTypes_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetTableTypes_presult__isset;
+
+class TCLIService_GetTableTypes_presult {
+ public:
+
+
+  virtual ~TCLIService_GetTableTypes_presult() throw();
+  TGetTableTypesResp* success;
+
+  _TCLIService_GetTableTypes_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetColumns_args__isset {
+  _TCLIService_GetColumns_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetColumns_args__isset;
+
+class TCLIService_GetColumns_args {
+ public:
+
+  TCLIService_GetColumns_args(const TCLIService_GetColumns_args&);
+  TCLIService_GetColumns_args& operator=(const TCLIService_GetColumns_args&);
+  TCLIService_GetColumns_args() {
+  }
+
+  virtual ~TCLIService_GetColumns_args() throw();
+  TGetColumnsReq req;
+
+  _TCLIService_GetColumns_args__isset __isset;
+
+  void __set_req(const TGetColumnsReq& val);
+
+  bool operator == (const TCLIService_GetColumns_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetColumns_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetColumns_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetColumns_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetColumns_pargs() throw();
+  const TGetColumnsReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetColumns_result__isset {
+  _TCLIService_GetColumns_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetColumns_result__isset;
+
+class TCLIService_GetColumns_result {
+ public:
+
+  TCLIService_GetColumns_result(const TCLIService_GetColumns_result&);
+  TCLIService_GetColumns_result& operator=(const TCLIService_GetColumns_result&);
+  TCLIService_GetColumns_result() {
+  }
+
+  virtual ~TCLIService_GetColumns_result() throw();
+  TGetColumnsResp success;
+
+  _TCLIService_GetColumns_result__isset __isset;
+
+  void __set_success(const TGetColumnsResp& val);
+
+  bool operator == (const TCLIService_GetColumns_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetColumns_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetColumns_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetColumns_presult__isset {
+  _TCLIService_GetColumns_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetColumns_presult__isset;
+
+class TCLIService_GetColumns_presult {
+ public:
+
+
+  virtual ~TCLIService_GetColumns_presult() throw();
+  TGetColumnsResp* success;
+
+  _TCLIService_GetColumns_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetFunctions_args__isset {
+  _TCLIService_GetFunctions_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetFunctions_args__isset;
+
+class TCLIService_GetFunctions_args {
+ public:
+
+  TCLIService_GetFunctions_args(const TCLIService_GetFunctions_args&);
+  TCLIService_GetFunctions_args& operator=(const TCLIService_GetFunctions_args&);
+  TCLIService_GetFunctions_args() {
+  }
+
+  virtual ~TCLIService_GetFunctions_args() throw();
+  TGetFunctionsReq req;
+
+  _TCLIService_GetFunctions_args__isset __isset;
+
+  void __set_req(const TGetFunctionsReq& val);
+
+  bool operator == (const TCLIService_GetFunctions_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetFunctions_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetFunctions_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetFunctions_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetFunctions_pargs() throw();
+  const TGetFunctionsReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetFunctions_result__isset {
+  _TCLIService_GetFunctions_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetFunctions_result__isset;
+
+class TCLIService_GetFunctions_result {
+ public:
+
+  TCLIService_GetFunctions_result(const TCLIService_GetFunctions_result&);
+  TCLIService_GetFunctions_result& operator=(const TCLIService_GetFunctions_result&);
+  TCLIService_GetFunctions_result() {
+  }
+
+  virtual ~TCLIService_GetFunctions_result() throw();
+  TGetFunctionsResp success;
+
+  _TCLIService_GetFunctions_result__isset __isset;
+
+  void __set_success(const TGetFunctionsResp& val);
+
+  bool operator == (const TCLIService_GetFunctions_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetFunctions_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetFunctions_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetFunctions_presult__isset {
+  _TCLIService_GetFunctions_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetFunctions_presult__isset;
+
+class TCLIService_GetFunctions_presult {
+ public:
+
+
+  virtual ~TCLIService_GetFunctions_presult() throw();
+  TGetFunctionsResp* success;
+
+  _TCLIService_GetFunctions_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetOperationStatus_args__isset {
+  _TCLIService_GetOperationStatus_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetOperationStatus_args__isset;
+
+class TCLIService_GetOperationStatus_args {
+ public:
+
+  TCLIService_GetOperationStatus_args(const TCLIService_GetOperationStatus_args&);
+  TCLIService_GetOperationStatus_args& operator=(const TCLIService_GetOperationStatus_args&);
+  TCLIService_GetOperationStatus_args() {
+  }
+
+  virtual ~TCLIService_GetOperationStatus_args() throw();
+  TGetOperationStatusReq req;
+
+  _TCLIService_GetOperationStatus_args__isset __isset;
+
+  void __set_req(const TGetOperationStatusReq& val);
+
+  bool operator == (const TCLIService_GetOperationStatus_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetOperationStatus_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetOperationStatus_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetOperationStatus_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetOperationStatus_pargs() throw();
+  const TGetOperationStatusReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetOperationStatus_result__isset {
+  _TCLIService_GetOperationStatus_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetOperationStatus_result__isset;
+
+class TCLIService_GetOperationStatus_result {
+ public:
+
+  TCLIService_GetOperationStatus_result(const TCLIService_GetOperationStatus_result&);
+  TCLIService_GetOperationStatus_result& operator=(const TCLIService_GetOperationStatus_result&);
+  TCLIService_GetOperationStatus_result() {
+  }
+
+  virtual ~TCLIService_GetOperationStatus_result() throw();
+  TGetOperationStatusResp success;
+
+  _TCLIService_GetOperationStatus_result__isset __isset;
+
+  void __set_success(const TGetOperationStatusResp& val);
+
+  bool operator == (const TCLIService_GetOperationStatus_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetOperationStatus_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetOperationStatus_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetOperationStatus_presult__isset {
+  _TCLIService_GetOperationStatus_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetOperationStatus_presult__isset;
+
+class TCLIService_GetOperationStatus_presult {
+ public:
+
+
+  virtual ~TCLIService_GetOperationStatus_presult() throw();
+  TGetOperationStatusResp* success;
+
+  _TCLIService_GetOperationStatus_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_CancelOperation_args__isset {
+  _TCLIService_CancelOperation_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_CancelOperation_args__isset;
+
+class TCLIService_CancelOperation_args {
+ public:
+
+  TCLIService_CancelOperation_args(const TCLIService_CancelOperation_args&);
+  TCLIService_CancelOperation_args& operator=(const TCLIService_CancelOperation_args&);
+  TCLIService_CancelOperation_args() {
+  }
+
+  virtual ~TCLIService_CancelOperation_args() throw();
+  TCancelOperationReq req;
+
+  _TCLIService_CancelOperation_args__isset __isset;
+
+  void __set_req(const TCancelOperationReq& val);
+
+  bool operator == (const TCLIService_CancelOperation_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CancelOperation_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CancelOperation_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_CancelOperation_pargs {
+ public:
+
+
+  virtual ~TCLIService_CancelOperation_pargs() throw();
+  const TCancelOperationReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelOperation_result__isset {
+  _TCLIService_CancelOperation_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CancelOperation_result__isset;
+
+class TCLIService_CancelOperation_result {
+ public:
+
+  TCLIService_CancelOperation_result(const TCLIService_CancelOperation_result&);
+  TCLIService_CancelOperation_result& operator=(const TCLIService_CancelOperation_result&);
+  TCLIService_CancelOperation_result() {
+  }
+
+  virtual ~TCLIService_CancelOperation_result() throw();
+  TCancelOperationResp success;
+
+  _TCLIService_CancelOperation_result__isset __isset;
+
+  void __set_success(const TCancelOperationResp& val);
+
+  bool operator == (const TCLIService_CancelOperation_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CancelOperation_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CancelOperation_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelOperation_presult__isset {
+  _TCLIService_CancelOperation_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CancelOperation_presult__isset;
+
+class TCLIService_CancelOperation_presult {
+ public:
+
+
+  virtual ~TCLIService_CancelOperation_presult() throw();
+  TCancelOperationResp* success;
+
+  _TCLIService_CancelOperation_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_CloseOperation_args__isset {
+  _TCLIService_CloseOperation_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_CloseOperation_args__isset;
+
+class TCLIService_CloseOperation_args {
+ public:
+
+  TCLIService_CloseOperation_args(const TCLIService_CloseOperation_args&);
+  TCLIService_CloseOperation_args& operator=(const TCLIService_CloseOperation_args&);
+  TCLIService_CloseOperation_args() {
+  }
+
+  virtual ~TCLIService_CloseOperation_args() throw();
+  TCloseOperationReq req;
+
+  _TCLIService_CloseOperation_args__isset __isset;
+
+  void __set_req(const TCloseOperationReq& val);
+
+  bool operator == (const TCLIService_CloseOperation_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CloseOperation_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CloseOperation_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_CloseOperation_pargs {
+ public:
+
+
+  virtual ~TCLIService_CloseOperation_pargs() throw();
+  const TCloseOperationReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CloseOperation_result__isset {
+  _TCLIService_CloseOperation_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CloseOperation_result__isset;
+
+class TCLIService_CloseOperation_result {
+ public:
+
+  TCLIService_CloseOperation_result(const TCLIService_CloseOperation_result&);
+  TCLIService_CloseOperation_result& operator=(const TCLIService_CloseOperation_result&);
+  TCLIService_CloseOperation_result() {
+  }
+
+  virtual ~TCLIService_CloseOperation_result() throw();
+  TCloseOperationResp success;
+
+  _TCLIService_CloseOperation_result__isset __isset;
+
+  void __set_success(const TCloseOperationResp& val);
+
+  bool operator == (const TCLIService_CloseOperation_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CloseOperation_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CloseOperation_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CloseOperation_presult__isset {
+  _TCLIService_CloseOperation_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CloseOperation_presult__isset;
+
+class TCLIService_CloseOperation_presult {
+ public:
+
+
+  virtual ~TCLIService_CloseOperation_presult() throw();
+  TCloseOperationResp* success;
+
+  _TCLIService_CloseOperation_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetResultSetMetadata_args__isset {
+  _TCLIService_GetResultSetMetadata_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetResultSetMetadata_args__isset;
+
+class TCLIService_GetResultSetMetadata_args {
+ public:
+
+  TCLIService_GetResultSetMetadata_args(const TCLIService_GetResultSetMetadata_args&);
+  TCLIService_GetResultSetMetadata_args& operator=(const TCLIService_GetResultSetMetadata_args&);
+  TCLIService_GetResultSetMetadata_args() {
+  }
+
+  virtual ~TCLIService_GetResultSetMetadata_args() throw();
+  TGetResultSetMetadataReq req;
+
+  _TCLIService_GetResultSetMetadata_args__isset __isset;
+
+  void __set_req(const TGetResultSetMetadataReq& val);
+
+  bool operator == (const TCLIService_GetResultSetMetadata_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetResultSetMetadata_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetResultSetMetadata_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetResultSetMetadata_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetResultSetMetadata_pargs() throw();
+  const TGetResultSetMetadataReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetResultSetMetadata_result__isset {
+  _TCLIService_GetResultSetMetadata_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetResultSetMetadata_result__isset;
+
+class TCLIService_GetResultSetMetadata_result {
+ public:
+
+  TCLIService_GetResultSetMetadata_result(const TCLIService_GetResultSetMetadata_result&);
+  TCLIService_GetResultSetMetadata_result& operator=(const TCLIService_GetResultSetMetadata_result&);
+  TCLIService_GetResultSetMetadata_result() {
+  }
+
+  virtual ~TCLIService_GetResultSetMetadata_result() throw();
+  TGetResultSetMetadataResp success;
+
+  _TCLIService_GetResultSetMetadata_result__isset __isset;
+
+  void __set_success(const TGetResultSetMetadataResp& val);
+
+  bool operator == (const TCLIService_GetResultSetMetadata_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetResultSetMetadata_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetResultSetMetadata_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetResultSetMetadata_presult__isset {
+  _TCLIService_GetResultSetMetadata_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetResultSetMetadata_presult__isset;
+
+class TCLIService_GetResultSetMetadata_presult {
+ public:
+
+
+  virtual ~TCLIService_GetResultSetMetadata_presult() throw();
+  TGetResultSetMetadataResp* success;
+
+  _TCLIService_GetResultSetMetadata_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_FetchResults_args__isset {
+  _TCLIService_FetchResults_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_FetchResults_args__isset;
+
+class TCLIService_FetchResults_args {
+ public:
+
+  TCLIService_FetchResults_args(const TCLIService_FetchResults_args&);
+  TCLIService_FetchResults_args& operator=(const TCLIService_FetchResults_args&);
+  TCLIService_FetchResults_args() {
+  }
+
+  virtual ~TCLIService_FetchResults_args() throw();
+  TFetchResultsReq req;
+
+  _TCLIService_FetchResults_args__isset __isset;
+
+  void __set_req(const TFetchResultsReq& val);
+
+  bool operator == (const TCLIService_FetchResults_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_FetchResults_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_FetchResults_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_FetchResults_pargs {
+ public:
+
+
+  virtual ~TCLIService_FetchResults_pargs() throw();
+  const TFetchResultsReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_FetchResults_result__isset {
+  _TCLIService_FetchResults_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_FetchResults_result__isset;
+
+class TCLIService_FetchResults_result {
+ public:
+
+  TCLIService_FetchResults_result(const TCLIService_FetchResults_result&);
+  TCLIService_FetchResults_result& operator=(const TCLIService_FetchResults_result&);
+  TCLIService_FetchResults_result() {
+  }
+
+  virtual ~TCLIService_FetchResults_result() throw();
+  TFetchResultsResp success;
+
+  _TCLIService_FetchResults_result__isset __isset;
+
+  void __set_success(const TFetchResultsResp& val);
+
+  bool operator == (const TCLIService_FetchResults_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_FetchResults_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_FetchResults_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_FetchResults_presult__isset {
+  _TCLIService_FetchResults_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_FetchResults_presult__isset;
+
+class TCLIService_FetchResults_presult {
+ public:
+
+
+  virtual ~TCLIService_FetchResults_presult() throw();
+  TFetchResultsResp* success;
+
+  _TCLIService_FetchResults_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_GetDelegationToken_args__isset {
+  _TCLIService_GetDelegationToken_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_GetDelegationToken_args__isset;
+
+class TCLIService_GetDelegationToken_args {
+ public:
+
+  TCLIService_GetDelegationToken_args(const TCLIService_GetDelegationToken_args&);
+  TCLIService_GetDelegationToken_args& operator=(const TCLIService_GetDelegationToken_args&);
+  TCLIService_GetDelegationToken_args() {
+  }
+
+  virtual ~TCLIService_GetDelegationToken_args() throw();
+  TGetDelegationTokenReq req;
+
+  _TCLIService_GetDelegationToken_args__isset __isset;
+
+  void __set_req(const TGetDelegationTokenReq& val);
+
+  bool operator == (const TCLIService_GetDelegationToken_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetDelegationToken_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetDelegationToken_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_GetDelegationToken_pargs {
+ public:
+
+
+  virtual ~TCLIService_GetDelegationToken_pargs() throw();
+  const TGetDelegationTokenReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetDelegationToken_result__isset {
+  _TCLIService_GetDelegationToken_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetDelegationToken_result__isset;
+
+class TCLIService_GetDelegationToken_result {
+ public:
+
+  TCLIService_GetDelegationToken_result(const TCLIService_GetDelegationToken_result&);
+  TCLIService_GetDelegationToken_result& operator=(const TCLIService_GetDelegationToken_result&);
+  TCLIService_GetDelegationToken_result() {
+  }
+
+  virtual ~TCLIService_GetDelegationToken_result() throw();
+  TGetDelegationTokenResp success;
+
+  _TCLIService_GetDelegationToken_result__isset __isset;
+
+  void __set_success(const TGetDelegationTokenResp& val);
+
+  bool operator == (const TCLIService_GetDelegationToken_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_GetDelegationToken_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_GetDelegationToken_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_GetDelegationToken_presult__isset {
+  _TCLIService_GetDelegationToken_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_GetDelegationToken_presult__isset;
+
+class TCLIService_GetDelegationToken_presult {
+ public:
+
+
+  virtual ~TCLIService_GetDelegationToken_presult() throw();
+  TGetDelegationTokenResp* success;
+
+  _TCLIService_GetDelegationToken_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_args__isset {
+  _TCLIService_CancelDelegationToken_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_CancelDelegationToken_args__isset;
+
+class TCLIService_CancelDelegationToken_args {
+ public:
+
+  TCLIService_CancelDelegationToken_args(const TCLIService_CancelDelegationToken_args&);
+  TCLIService_CancelDelegationToken_args& operator=(const TCLIService_CancelDelegationToken_args&);
+  TCLIService_CancelDelegationToken_args() {
+  }
+
+  virtual ~TCLIService_CancelDelegationToken_args() throw();
+  TCancelDelegationTokenReq req;
+
+  _TCLIService_CancelDelegationToken_args__isset __isset;
+
+  void __set_req(const TCancelDelegationTokenReq& val);
+
+  bool operator == (const TCLIService_CancelDelegationToken_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CancelDelegationToken_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CancelDelegationToken_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_CancelDelegationToken_pargs {
+ public:
+
+
+  virtual ~TCLIService_CancelDelegationToken_pargs() throw();
+  const TCancelDelegationTokenReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_result__isset {
+  _TCLIService_CancelDelegationToken_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CancelDelegationToken_result__isset;
+
+class TCLIService_CancelDelegationToken_result {
+ public:
+
+  TCLIService_CancelDelegationToken_result(const TCLIService_CancelDelegationToken_result&);
+  TCLIService_CancelDelegationToken_result& operator=(const TCLIService_CancelDelegationToken_result&);
+  TCLIService_CancelDelegationToken_result() {
+  }
+
+  virtual ~TCLIService_CancelDelegationToken_result() throw();
+  TCancelDelegationTokenResp success;
+
+  _TCLIService_CancelDelegationToken_result__isset __isset;
+
+  void __set_success(const TCancelDelegationTokenResp& val);
+
+  bool operator == (const TCLIService_CancelDelegationToken_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_CancelDelegationToken_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_CancelDelegationToken_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_CancelDelegationToken_presult__isset {
+  _TCLIService_CancelDelegationToken_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_CancelDelegationToken_presult__isset;
+
+class TCLIService_CancelDelegationToken_presult {
+ public:
+
+
+  virtual ~TCLIService_CancelDelegationToken_presult() throw();
+  TCancelDelegationTokenResp* success;
+
+  _TCLIService_CancelDelegationToken_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_args__isset {
+  _TCLIService_RenewDelegationToken_args__isset() : req(false) {}
+  bool req :1;
+} _TCLIService_RenewDelegationToken_args__isset;
+
+class TCLIService_RenewDelegationToken_args {
+ public:
+
+  TCLIService_RenewDelegationToken_args(const TCLIService_RenewDelegationToken_args&);
+  TCLIService_RenewDelegationToken_args& operator=(const TCLIService_RenewDelegationToken_args&);
+  TCLIService_RenewDelegationToken_args() {
+  }
+
+  virtual ~TCLIService_RenewDelegationToken_args() throw();
+  TRenewDelegationTokenReq req;
+
+  _TCLIService_RenewDelegationToken_args__isset __isset;
+
+  void __set_req(const TRenewDelegationTokenReq& val);
+
+  bool operator == (const TCLIService_RenewDelegationToken_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_RenewDelegationToken_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_RenewDelegationToken_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_RenewDelegationToken_pargs {
+ public:
+
+
+  virtual ~TCLIService_RenewDelegationToken_pargs() throw();
+  const TRenewDelegationTokenReq* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_result__isset {
+  _TCLIService_RenewDelegationToken_result__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_RenewDelegationToken_result__isset;
+
+class TCLIService_RenewDelegationToken_result {
+ public:
+
+  TCLIService_RenewDelegationToken_result(const TCLIService_RenewDelegationToken_result&);
+  TCLIService_RenewDelegationToken_result& operator=(const TCLIService_RenewDelegationToken_result&);
+  TCLIService_RenewDelegationToken_result() {
+  }
+
+  virtual ~TCLIService_RenewDelegationToken_result() throw();
+  TRenewDelegationTokenResp success;
+
+  _TCLIService_RenewDelegationToken_result__isset __isset;
+
+  void __set_success(const TRenewDelegationTokenResp& val);
+
+  bool operator == (const TCLIService_RenewDelegationToken_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const TCLIService_RenewDelegationToken_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const TCLIService_RenewDelegationToken_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_RenewDelegationToken_presult__isset {
+  _TCLIService_RenewDelegationToken_presult__isset() : success(false) {}
+  bool success :1;
+} _TCLIService_RenewDelegationToken_presult__isset;
+
+class TCLIService_RenewDelegationToken_presult {
+ public:
+
+
+  virtual ~TCLIService_RenewDelegationToken_presult() throw();
+  TRenewDelegationTokenResp* success;
+
+  _TCLIService_RenewDelegationToken_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class TCLIServiceClient : virtual public TCLIServiceIf {
+ public:
+  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req);
+  void send_OpenSession(const TOpenSessionReq& req);
+  void recv_OpenSession(TOpenSessionResp& _return);
+  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req);
+  void send_CloseSession(const TCloseSessionReq& req);
+  void recv_CloseSession(TCloseSessionResp& _return);
+  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req);
+  void send_GetInfo(const TGetInfoReq& req);
+  void recv_GetInfo(TGetInfoResp& _return);
+  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req);
+  void send_ExecuteStatement(const TExecuteStatementReq& req);
+  void recv_ExecuteStatement(TExecuteStatementResp& _return);
+  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req);
+  void send_GetTypeInfo(const TGetTypeInfoReq& req);
+  void recv_GetTypeInfo(TGetTypeInfoResp& _return);
+  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req);
+  void send_GetCatalogs(const TGetCatalogsReq& req);
+  void recv_GetCatalogs(TGetCatalogsResp& _return);
+  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req);
+  void send_GetSchemas(const TGetSchemasReq& req);
+  void recv_GetSchemas(TGetSchemasResp& _return);
+  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req);
+  void send_GetTables(const TGetTablesReq& req);
+  void recv_GetTables(TGetTablesResp& _return);
+  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req);
+  void send_GetTableTypes(const TGetTableTypesReq& req);
+  void recv_GetTableTypes(TGetTableTypesResp& _return);
+  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req);
+  void send_GetColumns(const TGetColumnsReq& req);
+  void recv_GetColumns(TGetColumnsResp& _return);
+  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req);
+  void send_GetFunctions(const TGetFunctionsReq& req);
+  void recv_GetFunctions(TGetFunctionsResp& _return);
+  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req);
+  void send_GetOperationStatus(const TGetOperationStatusReq& req);
+  void recv_GetOperationStatus(TGetOperationStatusResp& _return);
+  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req);
+  void send_CancelOperation(const TCancelOperationReq& req);
+  void recv_CancelOperation(TCancelOperationResp& _return);
+  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req);
+  void send_CloseOperation(const TCloseOperationReq& req);
+  void recv_CloseOperation(TCloseOperationResp& _return);
+  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req);
+  void send_GetResultSetMetadata(const TGetResultSetMetadataReq& req);
+  void recv_GetResultSetMetadata(TGetResultSetMetadataResp& _return);
+  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
+  void send_FetchResults(const TFetchResultsReq& req);
+  void recv_FetchResults(TFetchResultsResp& _return);
+  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
+  void send_GetDelegationToken(const TGetDelegationTokenReq& req);
+  void recv_GetDelegationToken(TGetDelegationTokenResp& _return);
+  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
+  void send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
+  void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return);
+  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
+  void send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
+  void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return);
+ protected:
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  boost::shared_ptr<TCLIServiceIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (TCLIServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_OpenSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_CloseSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_ExecuteStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetTypeInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetCatalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetSchemas(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetTableTypes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetFunctions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetOperationStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_CancelOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_CloseOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetResultSetMetadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_FetchResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_GetDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_CancelDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  TCLIServiceProcessor(boost::shared_ptr<TCLIServiceIf> iface) :
+    iface_(iface) {
+    processMap_["OpenSession"] = &TCLIServiceProcessor::process_OpenSession;
+    processMap_["CloseSession"] = &TCLIServiceProcessor::process_CloseSession;
+    processMap_["GetInfo"] = &TCLIServiceProcessor::process_GetInfo;
+    processMap_["ExecuteStatement"] = &TCLIServiceProcessor::process_ExecuteStatement;
+    processMap_["GetTypeInfo"] = &TCLIServiceProcessor::process_GetTypeInfo;
+    processMap_["GetCatalogs"] = &TCLIServiceProcessor::process_GetCatalogs;
+    processMap_["GetSchemas"] = &TCLIServiceProcessor::process_GetSchemas;
+    processMap_["GetTables"] = &TCLIServiceProcessor::process_GetTables;
+    processMap_["GetTableTypes"] = &TCLIServiceProcessor::process_GetTableTypes;
+    processMap_["GetColumns"] = &TCLIServiceProcessor::process_GetColumns;
+    processMap_["GetFunctions"] = &TCLIServiceProcessor::process_GetFunctions;
+    processMap_["GetOperationStatus"] = &TCLIServiceProcessor::process_GetOperationStatus;
+    processMap_["CancelOperation"] = &TCLIServiceProcessor::process_CancelOperation;
+    processMap_["CloseOperation"] = &TCLIServiceProcessor::process_CloseOperation;
+    processMap_["GetResultSetMetadata"] = &TCLIServiceProcessor::process_GetResultSetMetadata;
+    processMap_["FetchResults"] = &TCLIServiceProcessor::process_FetchResults;
+    processMap_["GetDelegationToken"] = &TCLIServiceProcessor::process_GetDelegationToken;
+    processMap_["CancelDelegationToken"] = &TCLIServiceProcessor::process_CancelDelegationToken;
+    processMap_["RenewDelegationToken"] = &TCLIServiceProcessor::process_RenewDelegationToken;
+  }
+
+  virtual ~TCLIServiceProcessor() {}
+};
+
+class TCLIServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  TCLIServiceProcessorFactory(const ::boost::shared_ptr< TCLIServiceIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::boost::shared_ptr< TCLIServiceIfFactory > handlerFactory_;
+};
+
+class TCLIServiceMultiface : virtual public TCLIServiceIf {
+ public:
+  TCLIServiceMultiface(std::vector<boost::shared_ptr<TCLIServiceIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~TCLIServiceMultiface() {}
+ protected:
+  std::vector<boost::shared_ptr<TCLIServiceIf> > ifaces_;
+  TCLIServiceMultiface() {}
+  void add(boost::shared_ptr<TCLIServiceIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->OpenSession(_return, req);
+    }
+    ifaces_[i]->OpenSession(_return, req);
+    return;
+  }
+
+  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->CloseSession(_return, req);
+    }
+    ifaces_[i]->CloseSession(_return, req);
+    return;
+  }
+
+  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetInfo(_return, req);
+    }
+    ifaces_[i]->GetInfo(_return, req);
+    return;
+  }
+
+  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->ExecuteStatement(_return, req);
+    }
+    ifaces_[i]->ExecuteStatement(_return, req);
+    return;
+  }
+
+  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetTypeInfo(_return, req);
+    }
+    ifaces_[i]->GetTypeInfo(_return, req);
+    return;
+  }
+
+  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetCatalogs(_return, req);
+    }
+    ifaces_[i]->GetCatalogs(_return, req);
+    return;
+  }
+
+  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetSchemas(_return, req);
+    }
+    ifaces_[i]->GetSchemas(_return, req);
+    return;
+  }
+
+  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetTables(_return, req);
+    }
+    ifaces_[i]->GetTables(_return, req);
+    return;
+  }
+
+  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetTableTypes(_return, req);
+    }
+    ifaces_[i]->GetTableTypes(_return, req);
+    return;
+  }
+
+  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetColumns(_return, req);
+    }
+    ifaces_[i]->GetColumns(_return, req);
+    return;
+  }
+
+  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetFunctions(_return, req);
+    }
+    ifaces_[i]->GetFunctions(_return, req);
+    return;
+  }
+
+  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetOperationStatus(_return, req);
+    }
+    ifaces_[i]->GetOperationStatus(_return, req);
+    return;
+  }
+
+  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->CancelOperation(_return, req);
+    }
+    ifaces_[i]->CancelOperation(_return, req);
+    return;
+  }
+
+  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->CloseOperation(_return, req);
+    }
+    ifaces_[i]->CloseOperation(_return, req);
+    return;
+  }
+
+  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetResultSetMetadata(_return, req);
+    }
+    ifaces_[i]->GetResultSetMetadata(_return, req);
+    return;
+  }
+
+  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->FetchResults(_return, req);
+    }
+    ifaces_[i]->FetchResults(_return, req);
+    return;
+  }
+
+  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->GetDelegationToken(_return, req);
+    }
+    ifaces_[i]->GetDelegationToken(_return, req);
+    return;
+  }
+
+  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->CancelDelegationToken(_return, req);
+    }
+    ifaces_[i]->CancelDelegationToken(_return, req);
+    return;
+  }
+
+  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->RenewDelegationToken(_return, req);
+    }
+    ifaces_[i]->RenewDelegationToken(_return, req);
+    return;
+  }
+
+};
+
+// The 'concurrent' client is a thread safe client that correctly handles
+// out of order responses.  It is slower than the regular client, so should
+// only be used when you need to share a connection among multiple threads
+class TCLIServiceConcurrentClient : virtual public TCLIServiceIf {
+ public:
+  TCLIServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  TCLIServiceConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req);
+  int32_t send_OpenSession(const TOpenSessionReq& req);
+  void recv_OpenSession(TOpenSessionResp& _return, const int32_t seqid);
+  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req);
+  int32_t send_CloseSession(const TCloseSessionReq& req);
+  void recv_CloseSession(TCloseSessionResp& _return, const int32_t seqid);
+  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req);
+  int32_t send_GetInfo(const TGetInfoReq& req);
+  void recv_GetInfo(TGetInfoResp& _return, const int32_t seqid);
+  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req);
+  int32_t send_ExecuteStatement(const TExecuteStatementReq& req);
+  void recv_ExecuteStatement(TExecuteStatementResp& _return, const int32_t seqid);
+  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req);
+  int32_t send_GetTypeInfo(const TGetTypeInfoReq& req);
+  void recv_GetTypeInfo(TGetTypeInfoResp& _return, const int32_t seqid);
+  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req);
+  int32_t send_GetCatalogs(const TGetCatalogsReq& req);
+  void recv_GetCatalogs(TGetCatalogsResp& _return, const int32_t seqid);
+  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req);
+  int32_t send_GetSchemas(const TGetSchemasReq& req);
+  void recv_GetSchemas(TGetSchemasResp& _return, const int32_t seqid);
+  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req);
+  int32_t send_GetTables(const TGetTablesReq& req);
+  void recv_GetTables(TGetTablesResp& _return, const int32_t seqid);
+  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req);
+  int32_t send_GetTableTypes(const TGetTableTypesReq& req);
+  void recv_GetTableTypes(TGetTableTypesResp& _return, const int32_t seqid);
+  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req);
+  int32_t send_GetColumns(const TGetColumnsReq& req);
+  void recv_GetColumns(TGetColumnsResp& _return, const int32_t seqid);
+  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req);
+  int32_t send_GetFunctions(const TGetFunctionsReq& req);
+  void recv_GetFunctions(TGetFunctionsResp& _return, const int32_t seqid);
+  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req);
+  int32_t send_GetOperationStatus(const TGetOperationStatusReq& req);
+  void recv_GetOperationStatus(TGetOperationStatusResp& _return, const int32_t seqid);
+  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req);
+  int32_t send_CancelOperation(const TCancelOperationReq& req);
+  void recv_CancelOperation(TCancelOperationResp& _return, const int32_t seqid);
+  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req);
+  int32_t send_CloseOperation(const TCloseOperationReq& req);
+  void recv_CloseOperation(TCloseOperationResp& _return, const int32_t seqid);
+  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req);
+  int32_t send_GetResultSetMetadata(const TGetResultSetMetadataReq& req);
+  void recv_GetResultSetMetadata(TGetResultSetMetadataResp& _return, const int32_t seqid);
+  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
+  int32_t send_FetchResults(const TFetchResultsReq& req);
+  void recv_FetchResults(TFetchResultsResp& _return, const int32_t seqid);
+  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
+  int32_t send_GetDelegationToken(const TGetDelegationTokenReq& req);
+  void recv_GetDelegationToken(TGetDelegationTokenResp& _return, const int32_t seqid);
+  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
+  int32_t send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
+  void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return, const int32_t seqid);
+  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
+  int32_t send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
+  void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return, const int32_t seqid);
+ protected:
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+  ::apache::thrift::async::TConcurrentClientSyncInfo sync_;
+};
+
+#ifdef _WIN32
+  #pragma warning( pop )
+#endif
+
+}}}}} // namespace
+
+#endif

http://git-wip-us.apache.org/repos/asf/hive/blob/3a1c4b57/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
new file mode 100644
index 0000000..991cb2e
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.cpp
@@ -0,0 +1,72 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "TCLIService_constants.h"
+
+namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift {
+
+const TCLIServiceConstants g_TCLIService_constants;
+
+TCLIServiceConstants::TCLIServiceConstants() {
+  PRIMITIVE_TYPES.insert((TTypeId::type)0);
+  PRIMITIVE_TYPES.insert((TTypeId::type)1);
+  PRIMITIVE_TYPES.insert((TTypeId::type)2);
+  PRIMITIVE_TYPES.insert((TTypeId::type)3);
+  PRIMITIVE_TYPES.insert((TTypeId::type)4);
+  PRIMITIVE_TYPES.insert((TTypeId::type)5);
+  PRIMITIVE_TYPES.insert((TTypeId::type)6);
+  PRIMITIVE_TYPES.insert((TTypeId::type)7);
+  PRIMITIVE_TYPES.insert((TTypeId::type)8);
+  PRIMITIVE_TYPES.insert((TTypeId::type)9);
+  PRIMITIVE_TYPES.insert((TTypeId::type)15);
+  PRIMITIVE_TYPES.insert((TTypeId::type)16);
+  PRIMITIVE_TYPES.insert((TTypeId::type)17);
+  PRIMITIVE_TYPES.insert((TTypeId::type)18);
+  PRIMITIVE_TYPES.insert((TTypeId::type)19);
+  PRIMITIVE_TYPES.insert((TTypeId::type)20);
+  PRIMITIVE_TYPES.insert((TTypeId::type)21);
+
+  COMPLEX_TYPES.insert((TTypeId::type)10);
+  COMPLEX_TYPES.insert((TTypeId::type)11);
+  COMPLEX_TYPES.insert((TTypeId::type)12);
+  COMPLEX_TYPES.insert((TTypeId::type)13);
+  COMPLEX_TYPES.insert((TTypeId::type)14);
+
+  COLLECTION_TYPES.insert((TTypeId::type)10);
+  COLLECTION_TYPES.insert((TTypeId::type)11);
+
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)0, "BOOLEAN"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)1, "TINYINT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)2, "SMALLINT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)3, "INT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)4, "BIGINT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)5, "FLOAT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)6, "DOUBLE"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)7, "STRING"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)8, "TIMESTAMP"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)9, "BINARY"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)10, "ARRAY"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)11, "MAP"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)12, "STRUCT"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)13, "UNIONTYPE"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)15, "DECIMAL"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)16, "NULL"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)17, "DATE"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)18, "VARCHAR"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)19, "CHAR"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)20, "INTERVAL_YEAR_MONTH"));
+  TYPE_NAMES.insert(std::make_pair((TTypeId::type)21, "INTERVAL_DAY_TIME"));
+
+  CHARACTER_MAXIMUM_LENGTH = "characterMaximumLength";
+
+  PRECISION = "precision";
+
+  SCALE = "scale";
+
+}
+
+}}}}} // namespace
+

http://git-wip-us.apache.org/repos/asf/hive/blob/3a1c4b57/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.h
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.h
new file mode 100644
index 0000000..3f8414d
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_constants.h
@@ -0,0 +1,31 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef TCLIService_CONSTANTS_H
+#define TCLIService_CONSTANTS_H
+
+#include "TCLIService_types.h"
+
+namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift {
+
+class TCLIServiceConstants {
+ public:
+  TCLIServiceConstants();
+
+  std::set<TTypeId::type>  PRIMITIVE_TYPES;
+  std::set<TTypeId::type>  COMPLEX_TYPES;
+  std::set<TTypeId::type>  COLLECTION_TYPES;
+  std::map<TTypeId::type, std::string>  TYPE_NAMES;
+  std::string CHARACTER_MAXIMUM_LENGTH;
+  std::string PRECISION;
+  std::string SCALE;
+};
+
+extern const TCLIServiceConstants g_TCLIService_constants;
+
+}}}}} // namespace
+
+#endif


Mime
View raw message