http://git-wip-us.apache.org/repos/asf/hive/blob/a28f6cd8/service/src/gen/thrift/gen-cpp/TCLIService.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/TCLIService.h b/service/src/gen/thrift/gen-cpp/TCLIService.h new file mode 100644 index 0000000..2ea80c7 --- /dev/null +++ b/service/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 cli { 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/a28f6cd8/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp b/service/src/gen/thrift/gen-cpp/TCLIService_constants.cpp new file mode 100644 index 0000000..60eeff7 --- /dev/null +++ b/service/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 cli { 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/a28f6cd8/service/src/gen/thrift/gen-cpp/TCLIService_constants.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_constants.h b/service/src/gen/thrift/gen-cpp/TCLIService_constants.h new file mode 100644 index 0000000..9310717 --- /dev/null +++ b/service/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 cli { 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