You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by su...@apache.org on 2022/01/15 17:30:05 UTC
[hive] branch master updated: HIVE-24893: Add UploadData and DownloadData to TCLIService.thrift (#2878)
This is an automated email from the ASF dual-hosted git repository.
sunchao pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hive.git
The following commit(s) were added to refs/heads/master by this push:
new 5b112aa HIVE-24893: Add UploadData and DownloadData to TCLIService.thrift (#2878)
5b112aa is described below
commit 5b112aa6dcc4e374c0a7c2b24042f24ae6815da1
Author: Yuming Wang <yu...@ebay.com>
AuthorDate: Sun Jan 16 01:29:48 2022 +0800
HIVE-24893: Add UploadData and DownloadData to TCLIService.thrift (#2878)
---
service-rpc/if/TCLIService.thrift | 50 +
service-rpc/src/gen/thrift/gen-cpp/TCLIService.cpp | 812 ++++++++-
service-rpc/src/gen/thrift/gen-cpp/TCLIService.h | 252 +++
.../thrift/gen-cpp/TCLIService_server.skeleton.cpp | 10 +
.../src/gen/thrift/gen-cpp/TCLIService_types.cpp | 1291 ++++++++++----
.../src/gen/thrift/gen-cpp/TCLIService_types.h | 225 +++
.../hive/service/rpc/thrift/TCLIService.java | 1762 ++++++++++++++++++++
.../{TGetTablesReq.java => TDownloadDataReq.java} | 540 +++---
.../hive/service/rpc/thrift/TDownloadDataResp.java | 477 ++++++
.../hive/service/rpc/thrift/TGetTablesReq.java | 32 +-
.../service/rpc/thrift/TProgressUpdateResp.java | 92 +-
.../{TGetTablesReq.java => TUploadDataReq.java} | 531 +++---
.../hive/service/rpc/thrift/TUploadDataResp.java | 477 ++++++
.../src/gen/thrift/gen-php/TCLIServiceClient.php | 118 ++
.../src/gen/thrift/gen-php/TCLIServiceIf.php | 10 +
.../gen-php/TCLIService_DownloadData_args.php | 97 ++
.../gen-php/TCLIService_DownloadData_result.php | 97 ++
.../thrift/gen-php/TCLIService_UploadData_args.php | 97 ++
.../gen-php/TCLIService_UploadData_result.php | 97 ++
.../{TGetTablesReq.php => TDownloadDataReq.php} | 108 +-
.../src/gen/thrift/gen-php/TDownloadDataResp.php | 126 ++
.../src/gen/thrift/gen-php/TGetTablesReq.php | 18 +-
.../src/gen/thrift/gen-php/TProgressUpdateResp.php | 54 +-
.../{TGetTablesReq.php => TUploadDataReq.php} | 98 +-
.../src/gen/thrift/gen-php/TUploadDataResp.php | 126 ++
.../thrift/gen-py/TCLIService/TCLIService-remote | 14 +
.../gen/thrift/gen-py/TCLIService/TCLIService.py | 378 +++++
.../src/gen/thrift/gen-py/TCLIService/ttypes.py | 434 ++++-
.../src/gen/thrift/gen-rb/t_c_l_i_service.rb | 108 ++
.../src/gen/thrift/gen-rb/t_c_l_i_service_types.rb | 97 ++
.../org/apache/hive/service/cli/CLIService.java | 28 +
.../hive/service/cli/EmbeddedCLIServiceClient.java | 20 +
.../org/apache/hive/service/cli/ICLIService.java | 14 +
.../service/cli/operation/OperationManager.java | 18 +
.../hive/service/cli/session/HiveSession.java | 27 +
.../hive/service/cli/session/HiveSessionImpl.java | 46 +
.../cli/thrift/RetryingThriftCLIServiceClient.java | 20 +
.../hive/service/cli/thrift/ThriftCLIService.java | 43 +
.../service/cli/thrift/ThriftCLIServiceClient.java | 48 +
39 files changed, 7671 insertions(+), 1221 deletions(-)
diff --git a/service-rpc/if/TCLIService.thrift b/service-rpc/if/TCLIService.thrift
index 217a9c7..a399e66 100644
--- a/service-rpc/if/TCLIService.thrift
+++ b/service-rpc/if/TCLIService.thrift
@@ -751,6 +751,52 @@ struct TGetTypeInfoResp {
2: optional TOperationHandle operationHandle
}
+// UploadData()
+//
+// UploadData data to table or path. One of tableName or path must be set.
+struct TUploadDataReq {
+ // The session to execute the statement against
+ 1: required TSessionHandle sessionHandle
+
+ // The table to be stored
+ 2: optional string tableName
+
+ // The path to be stored
+ 3: optional string path
+
+ // The data to be transferred
+ 4: required binary values
+}
+
+struct TUploadDataResp {
+ 1: required TStatus status
+ 2: required TOperationHandle operationHandle
+}
+
+// DownloadData()
+//
+// Download data to JDBC client. One of tableName or query must be set.
+struct TDownloadDataReq {
+ // The session to download data
+ 1: required TSessionHandle sessionHandle
+
+ // The download table name
+ 2: optional TPatternOrIdentifier tableName
+
+ // The download query. For example: SELECT * FROM t1 JOIN t2 ON t1.id = t2.id
+ 3: optional string query
+
+ // The download file format. For example: Parquet, ORC, CSV, JSON, Avro, etc.
+ 4: optional string format
+
+ // The download options. For example: dateFormat=yyyy-MM-dd, compression=gzip
+ 5: optional map<string, string> downloadOptions
+}
+
+struct TDownloadDataResp {
+ 1: required TStatus status
+ 2: required TOperationHandle operationHandle
+}
// GetCatalogs()
//
@@ -1297,4 +1343,8 @@ service TCLIService {
TGetQueryIdResp GetQueryId(1:TGetQueryIdReq req);
TSetClientInfoResp SetClientInfo(1:TSetClientInfoReq req);
+
+ TUploadDataResp UploadData(1:TUploadDataReq req);
+
+ TDownloadDataResp DownloadData(1:TDownloadDataReq req);
}
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.cpp
index 01f3933..53795bf 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.cpp
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.cpp
@@ -4309,6 +4309,380 @@ uint32_t TCLIService_SetClientInfo_presult::read(::apache::thrift::protocol::TPr
return xfer;
}
+
+TCLIService_UploadData_args::~TCLIService_UploadData_args() noexcept {
+}
+
+
+uint32_t TCLIService_UploadData_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_UploadData_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TCLIService_UploadData_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_UploadData_pargs::~TCLIService_UploadData_pargs() noexcept {
+}
+
+
+uint32_t TCLIService_UploadData_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TCLIService_UploadData_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_UploadData_result::~TCLIService_UploadData_result() noexcept {
+}
+
+
+uint32_t TCLIService_UploadData_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_UploadData_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("TCLIService_UploadData_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_UploadData_presult::~TCLIService_UploadData_presult() noexcept {
+}
+
+
+uint32_t TCLIService_UploadData_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+
+TCLIService_DownloadData_args::~TCLIService_DownloadData_args() noexcept {
+}
+
+
+uint32_t TCLIService_DownloadData_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_DownloadData_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TCLIService_DownloadData_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_DownloadData_pargs::~TCLIService_DownloadData_pargs() noexcept {
+}
+
+
+uint32_t TCLIService_DownloadData_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TCLIService_DownloadData_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_DownloadData_result::~TCLIService_DownloadData_result() noexcept {
+}
+
+
+uint32_t TCLIService_DownloadData_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TCLIService_DownloadData_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("TCLIService_DownloadData_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+TCLIService_DownloadData_presult::~TCLIService_DownloadData_presult() noexcept {
+}
+
+
+uint32_t TCLIService_DownloadData_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
void TCLIServiceClient::OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req)
{
send_OpenSession(req);
@@ -5509,12 +5883,128 @@ void TCLIServiceClient::recv_RenewDelegationToken(TRenewDelegationTokenResp& _re
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("RenewDelegationToken") != 0) {
+ if (fname.compare("RenewDelegationToken") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ TCLIService_RenewDelegationToken_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "RenewDelegationToken failed: unknown result");
+}
+
+void TCLIServiceClient::GetQueryId(TGetQueryIdResp& _return, const TGetQueryIdReq& req)
+{
+ send_GetQueryId(req);
+ recv_GetQueryId(_return);
+}
+
+void TCLIServiceClient::send_GetQueryId(const TGetQueryIdReq& req)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("GetQueryId", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_GetQueryId_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void TCLIServiceClient::recv_GetQueryId(TGetQueryIdResp& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("GetQueryId") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ TCLIService_GetQueryId_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "GetQueryId failed: unknown result");
+}
+
+void TCLIServiceClient::SetClientInfo(TSetClientInfoResp& _return, const TSetClientInfoReq& req)
+{
+ send_SetClientInfo(req);
+ recv_SetClientInfo(_return);
+}
+
+void TCLIServiceClient::send_SetClientInfo(const TSetClientInfoReq& req)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("SetClientInfo", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_SetClientInfo_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+}
+
+void TCLIServiceClient::recv_SetClientInfo(TSetClientInfoResp& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("SetClientInfo") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- TCLIService_RenewDelegationToken_presult result;
+ TCLIService_SetClientInfo_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -5524,21 +6014,21 @@ void TCLIServiceClient::recv_RenewDelegationToken(TRenewDelegationTokenResp& _re
// _return pointer has now been filled
return;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "RenewDelegationToken failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "SetClientInfo failed: unknown result");
}
-void TCLIServiceClient::GetQueryId(TGetQueryIdResp& _return, const TGetQueryIdReq& req)
+void TCLIServiceClient::UploadData(TUploadDataResp& _return, const TUploadDataReq& req)
{
- send_GetQueryId(req);
- recv_GetQueryId(_return);
+ send_UploadData(req);
+ recv_UploadData(_return);
}
-void TCLIServiceClient::send_GetQueryId(const TGetQueryIdReq& req)
+void TCLIServiceClient::send_UploadData(const TUploadDataReq& req)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("GetQueryId", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("UploadData", ::apache::thrift::protocol::T_CALL, cseqid);
- TCLIService_GetQueryId_pargs args;
+ TCLIService_UploadData_pargs args;
args.req = &req;
args.write(oprot_);
@@ -5547,7 +6037,7 @@ void TCLIServiceClient::send_GetQueryId(const TGetQueryIdReq& req)
oprot_->getTransport()->flush();
}
-void TCLIServiceClient::recv_GetQueryId(TGetQueryIdResp& _return)
+void TCLIServiceClient::recv_UploadData(TUploadDataResp& _return)
{
int32_t rseqid = 0;
@@ -5567,12 +6057,12 @@ void TCLIServiceClient::recv_GetQueryId(TGetQueryIdResp& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("GetQueryId") != 0) {
+ if (fname.compare("UploadData") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- TCLIService_GetQueryId_presult result;
+ TCLIService_UploadData_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -5582,21 +6072,21 @@ void TCLIServiceClient::recv_GetQueryId(TGetQueryIdResp& _return)
// _return pointer has now been filled
return;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "GetQueryId failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "UploadData failed: unknown result");
}
-void TCLIServiceClient::SetClientInfo(TSetClientInfoResp& _return, const TSetClientInfoReq& req)
+void TCLIServiceClient::DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req)
{
- send_SetClientInfo(req);
- recv_SetClientInfo(_return);
+ send_DownloadData(req);
+ recv_DownloadData(_return);
}
-void TCLIServiceClient::send_SetClientInfo(const TSetClientInfoReq& req)
+void TCLIServiceClient::send_DownloadData(const TDownloadDataReq& req)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("SetClientInfo", ::apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("DownloadData", ::apache::thrift::protocol::T_CALL, cseqid);
- TCLIService_SetClientInfo_pargs args;
+ TCLIService_DownloadData_pargs args;
args.req = &req;
args.write(oprot_);
@@ -5605,7 +6095,7 @@ void TCLIServiceClient::send_SetClientInfo(const TSetClientInfoReq& req)
oprot_->getTransport()->flush();
}
-void TCLIServiceClient::recv_SetClientInfo(TSetClientInfoResp& _return)
+void TCLIServiceClient::recv_DownloadData(TDownloadDataResp& _return)
{
int32_t rseqid = 0;
@@ -5625,12 +6115,12 @@ void TCLIServiceClient::recv_SetClientInfo(TSetClientInfoResp& _return)
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- if (fname.compare("SetClientInfo") != 0) {
+ if (fname.compare("DownloadData") != 0) {
iprot_->skip(::apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
}
- TCLIService_SetClientInfo_presult result;
+ TCLIService_DownloadData_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
@@ -5640,7 +6130,7 @@ void TCLIServiceClient::recv_SetClientInfo(TSetClientInfoResp& _return)
// _return pointer has now been filled
return;
}
- throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "SetClientInfo failed: unknown result");
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "DownloadData failed: unknown result");
}
bool TCLIServiceProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
@@ -6904,6 +7394,114 @@ void TCLIServiceProcessor::process_SetClientInfo(int32_t seqid, ::apache::thrift
}
}
+void TCLIServiceProcessor::process_UploadData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = nullptr;
+ if (this->eventHandler_.get() != nullptr) {
+ ctx = this->eventHandler_->getContext("TCLIService.UploadData", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TCLIService.UploadData");
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->preRead(ctx, "TCLIService.UploadData");
+ }
+
+ TCLIService_UploadData_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->postRead(ctx, "TCLIService.UploadData", bytes);
+ }
+
+ TCLIService_UploadData_result result;
+ try {
+ iface_->UploadData(result.success, args.req);
+ result.__isset.success = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->handlerError(ctx, "TCLIService.UploadData");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("UploadData", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->preWrite(ctx, "TCLIService.UploadData");
+ }
+
+ oprot->writeMessageBegin("UploadData", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->postWrite(ctx, "TCLIService.UploadData", bytes);
+ }
+}
+
+void TCLIServiceProcessor::process_DownloadData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+ void* ctx = nullptr;
+ if (this->eventHandler_.get() != nullptr) {
+ ctx = this->eventHandler_->getContext("TCLIService.DownloadData", callContext);
+ }
+ ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "TCLIService.DownloadData");
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->preRead(ctx, "TCLIService.DownloadData");
+ }
+
+ TCLIService_DownloadData_args args;
+ args.read(iprot);
+ iprot->readMessageEnd();
+ uint32_t bytes = iprot->getTransport()->readEnd();
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->postRead(ctx, "TCLIService.DownloadData", bytes);
+ }
+
+ TCLIService_DownloadData_result result;
+ try {
+ iface_->DownloadData(result.success, args.req);
+ result.__isset.success = true;
+ } catch (const std::exception& e) {
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->handlerError(ctx, "TCLIService.DownloadData");
+ }
+
+ ::apache::thrift::TApplicationException x(e.what());
+ oprot->writeMessageBegin("DownloadData", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+ x.write(oprot);
+ oprot->writeMessageEnd();
+ oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+ return;
+ }
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->preWrite(ctx, "TCLIService.DownloadData");
+ }
+
+ oprot->writeMessageBegin("DownloadData", ::apache::thrift::protocol::T_REPLY, seqid);
+ result.write(oprot);
+ oprot->writeMessageEnd();
+ bytes = oprot->getTransport()->writeEnd();
+ oprot->getTransport()->flush();
+
+ if (this->eventHandler_.get() != nullptr) {
+ this->eventHandler_->postWrite(ctx, "TCLIService.DownloadData", bytes);
+ }
+}
+
::std::shared_ptr< ::apache::thrift::TProcessor > TCLIServiceProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
::apache::thrift::ReleaseHandler< TCLIServiceIfFactory > cleanup(handlerFactory_);
::std::shared_ptr< TCLIServiceIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
@@ -8843,5 +9441,173 @@ void TCLIServiceConcurrentClient::recv_SetClientInfo(TSetClientInfoResp& _return
} // end while(true)
}
+void TCLIServiceConcurrentClient::UploadData(TUploadDataResp& _return, const TUploadDataReq& req)
+{
+ int32_t seqid = send_UploadData(req);
+ recv_UploadData(_return, seqid);
+}
+
+int32_t TCLIServiceConcurrentClient::send_UploadData(const TUploadDataReq& req)
+{
+ int32_t cseqid = this->sync_->generateSeqId();
+ ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+ oprot_->writeMessageBegin("UploadData", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_UploadData_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+
+ sentry.commit();
+ return cseqid;
+}
+
+void TCLIServiceConcurrentClient::recv_UploadData(TUploadDataResp& _return, const int32_t seqid)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ // the read mutex gets dropped and reacquired as part of waitForWork()
+ // The destructor of this sentry wakes up other clients
+ ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
+
+ while(true) {
+ if(!this->sync_->getPending(fname, mtype, rseqid)) {
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ }
+ if(seqid == rseqid) {
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ sentry.commit();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("UploadData") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ // in a bad state, don't commit
+ using ::apache::thrift::protocol::TProtocolException;
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ }
+ TCLIService_UploadData_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ sentry.commit();
+ return;
+ }
+ // in a bad state, don't commit
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "UploadData failed: unknown result");
+ }
+ // seqid != rseqid
+ this->sync_->updatePending(fname, mtype, rseqid);
+
+ // this will temporarily unlock the readMutex, and let other clients get work done
+ this->sync_->waitForWork(seqid);
+ } // end while(true)
+}
+
+void TCLIServiceConcurrentClient::DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req)
+{
+ int32_t seqid = send_DownloadData(req);
+ recv_DownloadData(_return, seqid);
+}
+
+int32_t TCLIServiceConcurrentClient::send_DownloadData(const TDownloadDataReq& req)
+{
+ int32_t cseqid = this->sync_->generateSeqId();
+ ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+ oprot_->writeMessageBegin("DownloadData", ::apache::thrift::protocol::T_CALL, cseqid);
+
+ TCLIService_DownloadData_pargs args;
+ args.req = &req;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->writeEnd();
+ oprot_->getTransport()->flush();
+
+ sentry.commit();
+ return cseqid;
+}
+
+void TCLIServiceConcurrentClient::recv_DownloadData(TDownloadDataResp& _return, const int32_t seqid)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TMessageType mtype;
+
+ // the read mutex gets dropped and reacquired as part of waitForWork()
+ // The destructor of this sentry wakes up other clients
+ ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
+
+ while(true) {
+ if(!this->sync_->getPending(fname, mtype, rseqid)) {
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ }
+ if(seqid == rseqid) {
+ if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+ ::apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ sentry.commit();
+ throw x;
+ }
+ if (mtype != ::apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ }
+ if (fname.compare("DownloadData") != 0) {
+ iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ // in a bad state, don't commit
+ using ::apache::thrift::protocol::TProtocolException;
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ }
+ TCLIService_DownloadData_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ sentry.commit();
+ return;
+ }
+ // in a bad state, don't commit
+ throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "DownloadData failed: unknown result");
+ }
+ // seqid != rseqid
+ this->sync_->updatePending(fname, mtype, rseqid);
+
+ // this will temporarily unlock the readMutex, and let other clients get work done
+ this->sync_->waitForWork(seqid);
+ } // end while(true)
+}
+
}}}}} // namespace
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
index 849624c..a4de3b3 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService.h
@@ -45,6 +45,8 @@ class TCLIServiceIf {
virtual void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) = 0;
virtual void GetQueryId(TGetQueryIdResp& _return, const TGetQueryIdReq& req) = 0;
virtual void SetClientInfo(TSetClientInfoResp& _return, const TSetClientInfoReq& req) = 0;
+ virtual void UploadData(TUploadDataResp& _return, const TUploadDataReq& req) = 0;
+ virtual void DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req) = 0;
};
class TCLIServiceIfFactory {
@@ -143,6 +145,12 @@ class TCLIServiceNull : virtual public TCLIServiceIf {
void SetClientInfo(TSetClientInfoResp& /* _return */, const TSetClientInfoReq& /* req */) {
return;
}
+ void UploadData(TUploadDataResp& /* _return */, const TUploadDataReq& /* req */) {
+ return;
+ }
+ void DownloadData(TDownloadDataResp& /* _return */, const TDownloadDataReq& /* req */) {
+ return;
+ }
};
typedef struct _TCLIService_OpenSession_args__isset {
@@ -2537,6 +2545,214 @@ class TCLIService_SetClientInfo_presult {
};
+typedef struct _TCLIService_UploadData_args__isset {
+ _TCLIService_UploadData_args__isset() : req(false) {}
+ bool req :1;
+} _TCLIService_UploadData_args__isset;
+
+class TCLIService_UploadData_args {
+ public:
+
+ TCLIService_UploadData_args(const TCLIService_UploadData_args&);
+ TCLIService_UploadData_args& operator=(const TCLIService_UploadData_args&);
+ TCLIService_UploadData_args() {
+ }
+
+ virtual ~TCLIService_UploadData_args() noexcept;
+ TUploadDataReq req;
+
+ _TCLIService_UploadData_args__isset __isset;
+
+ void __set_req(const TUploadDataReq& val);
+
+ bool operator == (const TCLIService_UploadData_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_UploadData_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_UploadData_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_UploadData_pargs {
+ public:
+
+
+ virtual ~TCLIService_UploadData_pargs() noexcept;
+ const TUploadDataReq* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_UploadData_result__isset {
+ _TCLIService_UploadData_result__isset() : success(false) {}
+ bool success :1;
+} _TCLIService_UploadData_result__isset;
+
+class TCLIService_UploadData_result {
+ public:
+
+ TCLIService_UploadData_result(const TCLIService_UploadData_result&);
+ TCLIService_UploadData_result& operator=(const TCLIService_UploadData_result&);
+ TCLIService_UploadData_result() {
+ }
+
+ virtual ~TCLIService_UploadData_result() noexcept;
+ TUploadDataResp success;
+
+ _TCLIService_UploadData_result__isset __isset;
+
+ void __set_success(const TUploadDataResp& val);
+
+ bool operator == (const TCLIService_UploadData_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_UploadData_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_UploadData_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_UploadData_presult__isset {
+ _TCLIService_UploadData_presult__isset() : success(false) {}
+ bool success :1;
+} _TCLIService_UploadData_presult__isset;
+
+class TCLIService_UploadData_presult {
+ public:
+
+
+ virtual ~TCLIService_UploadData_presult() noexcept;
+ TUploadDataResp* success;
+
+ _TCLIService_UploadData_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _TCLIService_DownloadData_args__isset {
+ _TCLIService_DownloadData_args__isset() : req(false) {}
+ bool req :1;
+} _TCLIService_DownloadData_args__isset;
+
+class TCLIService_DownloadData_args {
+ public:
+
+ TCLIService_DownloadData_args(const TCLIService_DownloadData_args&);
+ TCLIService_DownloadData_args& operator=(const TCLIService_DownloadData_args&);
+ TCLIService_DownloadData_args() {
+ }
+
+ virtual ~TCLIService_DownloadData_args() noexcept;
+ TDownloadDataReq req;
+
+ _TCLIService_DownloadData_args__isset __isset;
+
+ void __set_req(const TDownloadDataReq& val);
+
+ bool operator == (const TCLIService_DownloadData_args & rhs) const
+ {
+ if (!(req == rhs.req))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_DownloadData_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_DownloadData_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class TCLIService_DownloadData_pargs {
+ public:
+
+
+ virtual ~TCLIService_DownloadData_pargs() noexcept;
+ const TDownloadDataReq* req;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_DownloadData_result__isset {
+ _TCLIService_DownloadData_result__isset() : success(false) {}
+ bool success :1;
+} _TCLIService_DownloadData_result__isset;
+
+class TCLIService_DownloadData_result {
+ public:
+
+ TCLIService_DownloadData_result(const TCLIService_DownloadData_result&);
+ TCLIService_DownloadData_result& operator=(const TCLIService_DownloadData_result&);
+ TCLIService_DownloadData_result() {
+ }
+
+ virtual ~TCLIService_DownloadData_result() noexcept;
+ TDownloadDataResp success;
+
+ _TCLIService_DownloadData_result__isset __isset;
+
+ void __set_success(const TDownloadDataResp& val);
+
+ bool operator == (const TCLIService_DownloadData_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ return true;
+ }
+ bool operator != (const TCLIService_DownloadData_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TCLIService_DownloadData_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _TCLIService_DownloadData_presult__isset {
+ _TCLIService_DownloadData_presult__isset() : success(false) {}
+ bool success :1;
+} _TCLIService_DownloadData_presult__isset;
+
+class TCLIService_DownloadData_presult {
+ public:
+
+
+ virtual ~TCLIService_DownloadData_presult() noexcept;
+ TDownloadDataResp* success;
+
+ _TCLIService_DownloadData_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
class TCLIServiceClient : virtual public TCLIServiceIf {
public:
TCLIServiceClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
@@ -2631,6 +2847,12 @@ class TCLIServiceClient : virtual public TCLIServiceIf {
void SetClientInfo(TSetClientInfoResp& _return, const TSetClientInfoReq& req);
void send_SetClientInfo(const TSetClientInfoReq& req);
void recv_SetClientInfo(TSetClientInfoResp& _return);
+ void UploadData(TUploadDataResp& _return, const TUploadDataReq& req);
+ void send_UploadData(const TUploadDataReq& req);
+ void recv_UploadData(TUploadDataResp& _return);
+ void DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req);
+ void send_DownloadData(const TDownloadDataReq& req);
+ void recv_DownloadData(TDownloadDataResp& _return);
protected:
std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
@@ -2669,6 +2891,8 @@ class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
void process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_GetQueryId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_SetClientInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_UploadData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ void process_DownloadData(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
public:
TCLIServiceProcessor(::std::shared_ptr<TCLIServiceIf> iface) :
iface_(iface) {
@@ -2695,6 +2919,8 @@ class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
processMap_["RenewDelegationToken"] = &TCLIServiceProcessor::process_RenewDelegationToken;
processMap_["GetQueryId"] = &TCLIServiceProcessor::process_GetQueryId;
processMap_["SetClientInfo"] = &TCLIServiceProcessor::process_SetClientInfo;
+ processMap_["UploadData"] = &TCLIServiceProcessor::process_UploadData;
+ processMap_["DownloadData"] = &TCLIServiceProcessor::process_DownloadData;
}
virtual ~TCLIServiceProcessor() {}
@@ -2953,6 +3179,26 @@ class TCLIServiceMultiface : virtual public TCLIServiceIf {
return;
}
+ void UploadData(TUploadDataResp& _return, const TUploadDataReq& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->UploadData(_return, req);
+ }
+ ifaces_[i]->UploadData(_return, req);
+ return;
+ }
+
+ void DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->DownloadData(_return, req);
+ }
+ ifaces_[i]->DownloadData(_return, req);
+ return;
+ }
+
};
// The 'concurrent' client is a thread safe client that correctly handles
@@ -3054,6 +3300,12 @@ class TCLIServiceConcurrentClient : virtual public TCLIServiceIf {
void SetClientInfo(TSetClientInfoResp& _return, const TSetClientInfoReq& req);
int32_t send_SetClientInfo(const TSetClientInfoReq& req);
void recv_SetClientInfo(TSetClientInfoResp& _return, const int32_t seqid);
+ void UploadData(TUploadDataResp& _return, const TUploadDataReq& req);
+ int32_t send_UploadData(const TUploadDataReq& req);
+ void recv_UploadData(TUploadDataResp& _return, const int32_t seqid);
+ void DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req);
+ int32_t send_DownloadData(const TDownloadDataReq& req);
+ void recv_DownloadData(TDownloadDataResp& _return, const int32_t seqid);
protected:
std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
index f54a546..01d704e 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_server.skeleton.cpp
@@ -135,6 +135,16 @@ class TCLIServiceHandler : virtual public TCLIServiceIf {
printf("SetClientInfo\n");
}
+ void UploadData(TUploadDataResp& _return, const TUploadDataReq& req) {
+ // Your implementation goes here
+ printf("UploadData\n");
+ }
+
+ void DownloadData(TDownloadDataResp& _return, const TDownloadDataReq& req) {
+ // Your implementation goes here
+ printf("DownloadData\n");
+ }
+
};
int main(int argc, char **argv) {
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
index 9a46449..358118e9 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -6804,6 +6804,605 @@ void TGetTypeInfoResp::printTo(std::ostream& out) const {
}
+TUploadDataReq::~TUploadDataReq() noexcept {
+}
+
+
+void TUploadDataReq::__set_sessionHandle(const TSessionHandle& val) {
+ this->sessionHandle = val;
+}
+
+void TUploadDataReq::__set_tableName(const std::string& val) {
+ this->tableName = val;
+__isset.tableName = true;
+}
+
+void TUploadDataReq::__set_path(const std::string& val) {
+ this->path = val;
+__isset.path = true;
+}
+
+void TUploadDataReq::__set_values(const std::string& val) {
+ this->values = val;
+}
+std::ostream& operator<<(std::ostream& out, const TUploadDataReq& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+uint32_t TUploadDataReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_sessionHandle = false;
+ bool isset_values = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ this->__isset.tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->path);
+ this->__isset.path = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->values);
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TUploadDataReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TUploadDataReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.tableName) {
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.path) {
+ xfer += oprot->writeFieldBegin("path", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->path);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeBinary(this->values);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TUploadDataReq &a, TUploadDataReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.tableName, b.tableName);
+ swap(a.path, b.path);
+ swap(a.values, b.values);
+ swap(a.__isset, b.__isset);
+}
+
+TUploadDataReq::TUploadDataReq(const TUploadDataReq& other242) {
+ sessionHandle = other242.sessionHandle;
+ tableName = other242.tableName;
+ path = other242.path;
+ values = other242.values;
+ __isset = other242.__isset;
+}
+TUploadDataReq& TUploadDataReq::operator=(const TUploadDataReq& other243) {
+ sessionHandle = other243.sessionHandle;
+ tableName = other243.tableName;
+ path = other243.path;
+ values = other243.values;
+ __isset = other243.__isset;
+ return *this;
+}
+void TUploadDataReq::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TUploadDataReq(";
+ out << "sessionHandle=" << to_string(sessionHandle);
+ out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "<null>"));
+ out << ", " << "path="; (__isset.path ? (out << to_string(path)) : (out << "<null>"));
+ out << ", " << "values=" << to_string(values);
+ out << ")";
+}
+
+
+TUploadDataResp::~TUploadDataResp() noexcept {
+}
+
+
+void TUploadDataResp::__set_status(const TStatus& val) {
+ this->status = val;
+}
+
+void TUploadDataResp::__set_operationHandle(const TOperationHandle& val) {
+ this->operationHandle = val;
+}
+std::ostream& operator<<(std::ostream& out, const TUploadDataResp& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+uint32_t TUploadDataResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_status = false;
+ bool isset_operationHandle = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->operationHandle.read(iprot);
+ isset_operationHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_operationHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TUploadDataResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TUploadDataResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("operationHandle", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->operationHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TUploadDataResp &a, TUploadDataResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.operationHandle, b.operationHandle);
+}
+
+TUploadDataResp::TUploadDataResp(const TUploadDataResp& other244) {
+ status = other244.status;
+ operationHandle = other244.operationHandle;
+}
+TUploadDataResp& TUploadDataResp::operator=(const TUploadDataResp& other245) {
+ status = other245.status;
+ operationHandle = other245.operationHandle;
+ return *this;
+}
+void TUploadDataResp::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TUploadDataResp(";
+ out << "status=" << to_string(status);
+ out << ", " << "operationHandle=" << to_string(operationHandle);
+ out << ")";
+}
+
+
+TDownloadDataReq::~TDownloadDataReq() noexcept {
+}
+
+
+void TDownloadDataReq::__set_sessionHandle(const TSessionHandle& val) {
+ this->sessionHandle = val;
+}
+
+void TDownloadDataReq::__set_tableName(const TPatternOrIdentifier& val) {
+ this->tableName = val;
+__isset.tableName = true;
+}
+
+void TDownloadDataReq::__set_query(const std::string& val) {
+ this->query = val;
+__isset.query = true;
+}
+
+void TDownloadDataReq::__set_format(const std::string& val) {
+ this->format = val;
+__isset.format = true;
+}
+
+void TDownloadDataReq::__set_downloadOptions(const std::map<std::string, std::string> & val) {
+ this->downloadOptions = val;
+__isset.downloadOptions = true;
+}
+std::ostream& operator<<(std::ostream& out, const TDownloadDataReq& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+uint32_t TDownloadDataReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_sessionHandle = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->sessionHandle.read(iprot);
+ isset_sessionHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ this->__isset.tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->query);
+ this->__isset.query = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->format);
+ this->__isset.format = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->downloadOptions.clear();
+ uint32_t _size246;
+ ::apache::thrift::protocol::TType _ktype247;
+ ::apache::thrift::protocol::TType _vtype248;
+ xfer += iprot->readMapBegin(_ktype247, _vtype248, _size246);
+ uint32_t _i250;
+ for (_i250 = 0; _i250 < _size246; ++_i250)
+ {
+ std::string _key251;
+ xfer += iprot->readString(_key251);
+ std::string& _val252 = this->downloadOptions[_key251];
+ xfer += iprot->readString(_val252);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.downloadOptions = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_sessionHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TDownloadDataReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TDownloadDataReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.tableName) {
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.query) {
+ xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->query);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.format) {
+ xfer += oprot->writeFieldBegin("format", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->format);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.downloadOptions) {
+ xfer += oprot->writeFieldBegin("downloadOptions", ::apache::thrift::protocol::T_MAP, 5);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->downloadOptions.size()));
+ std::map<std::string, std::string> ::const_iterator _iter253;
+ for (_iter253 = this->downloadOptions.begin(); _iter253 != this->downloadOptions.end(); ++_iter253)
+ {
+ xfer += oprot->writeString(_iter253->first);
+ xfer += oprot->writeString(_iter253->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TDownloadDataReq &a, TDownloadDataReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.tableName, b.tableName);
+ swap(a.query, b.query);
+ swap(a.format, b.format);
+ swap(a.downloadOptions, b.downloadOptions);
+ swap(a.__isset, b.__isset);
+}
+
+TDownloadDataReq::TDownloadDataReq(const TDownloadDataReq& other254) {
+ sessionHandle = other254.sessionHandle;
+ tableName = other254.tableName;
+ query = other254.query;
+ format = other254.format;
+ downloadOptions = other254.downloadOptions;
+ __isset = other254.__isset;
+}
+TDownloadDataReq& TDownloadDataReq::operator=(const TDownloadDataReq& other255) {
+ sessionHandle = other255.sessionHandle;
+ tableName = other255.tableName;
+ query = other255.query;
+ format = other255.format;
+ downloadOptions = other255.downloadOptions;
+ __isset = other255.__isset;
+ return *this;
+}
+void TDownloadDataReq::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TDownloadDataReq(";
+ out << "sessionHandle=" << to_string(sessionHandle);
+ out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "<null>"));
+ out << ", " << "query="; (__isset.query ? (out << to_string(query)) : (out << "<null>"));
+ out << ", " << "format="; (__isset.format ? (out << to_string(format)) : (out << "<null>"));
+ out << ", " << "downloadOptions="; (__isset.downloadOptions ? (out << to_string(downloadOptions)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TDownloadDataResp::~TDownloadDataResp() noexcept {
+}
+
+
+void TDownloadDataResp::__set_status(const TStatus& val) {
+ this->status = val;
+}
+
+void TDownloadDataResp::__set_operationHandle(const TOperationHandle& val) {
+ this->operationHandle = val;
+}
+std::ostream& operator<<(std::ostream& out, const TDownloadDataResp& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+uint32_t TDownloadDataResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_status = false;
+ bool isset_operationHandle = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->status.read(iprot);
+ isset_status = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->operationHandle.read(iprot);
+ isset_operationHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_status)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_operationHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TDownloadDataResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TDownloadDataResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("operationHandle", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->operationHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TDownloadDataResp &a, TDownloadDataResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.operationHandle, b.operationHandle);
+}
+
+TDownloadDataResp::TDownloadDataResp(const TDownloadDataResp& other256) {
+ status = other256.status;
+ operationHandle = other256.operationHandle;
+}
+TDownloadDataResp& TDownloadDataResp::operator=(const TDownloadDataResp& other257) {
+ status = other257.status;
+ operationHandle = other257.operationHandle;
+ return *this;
+}
+void TDownloadDataResp::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TDownloadDataResp(";
+ out << "status=" << to_string(status);
+ out << ", " << "operationHandle=" << to_string(operationHandle);
+ out << ")";
+}
+
+
TGetCatalogsReq::~TGetCatalogsReq() noexcept {
}
@@ -6881,11 +7480,11 @@ void swap(TGetCatalogsReq &a, TGetCatalogsReq &b) {
swap(a.sessionHandle, b.sessionHandle);
}
-TGetCatalogsReq::TGetCatalogsReq(const TGetCatalogsReq& other242) {
- sessionHandle = other242.sessionHandle;
+TGetCatalogsReq::TGetCatalogsReq(const TGetCatalogsReq& other258) {
+ sessionHandle = other258.sessionHandle;
}
-TGetCatalogsReq& TGetCatalogsReq::operator=(const TGetCatalogsReq& other243) {
- sessionHandle = other243.sessionHandle;
+TGetCatalogsReq& TGetCatalogsReq::operator=(const TGetCatalogsReq& other259) {
+ sessionHandle = other259.sessionHandle;
return *this;
}
void TGetCatalogsReq::printTo(std::ostream& out) const {
@@ -6993,15 +7592,15 @@ void swap(TGetCatalogsResp &a, TGetCatalogsResp &b) {
swap(a.__isset, b.__isset);
}
-TGetCatalogsResp::TGetCatalogsResp(const TGetCatalogsResp& other244) {
- status = other244.status;
- operationHandle = other244.operationHandle;
- __isset = other244.__isset;
+TGetCatalogsResp::TGetCatalogsResp(const TGetCatalogsResp& other260) {
+ status = other260.status;
+ operationHandle = other260.operationHandle;
+ __isset = other260.__isset;
}
-TGetCatalogsResp& TGetCatalogsResp::operator=(const TGetCatalogsResp& other245) {
- status = other245.status;
- operationHandle = other245.operationHandle;
- __isset = other245.__isset;
+TGetCatalogsResp& TGetCatalogsResp::operator=(const TGetCatalogsResp& other261) {
+ status = other261.status;
+ operationHandle = other261.operationHandle;
+ __isset = other261.__isset;
return *this;
}
void TGetCatalogsResp::printTo(std::ostream& out) const {
@@ -7129,17 +7728,17 @@ void swap(TGetSchemasReq &a, TGetSchemasReq &b) {
swap(a.__isset, b.__isset);
}
-TGetSchemasReq::TGetSchemasReq(const TGetSchemasReq& other246) {
- sessionHandle = other246.sessionHandle;
- catalogName = other246.catalogName;
- schemaName = other246.schemaName;
- __isset = other246.__isset;
+TGetSchemasReq::TGetSchemasReq(const TGetSchemasReq& other262) {
+ sessionHandle = other262.sessionHandle;
+ catalogName = other262.catalogName;
+ schemaName = other262.schemaName;
+ __isset = other262.__isset;
}
-TGetSchemasReq& TGetSchemasReq::operator=(const TGetSchemasReq& other247) {
- sessionHandle = other247.sessionHandle;
- catalogName = other247.catalogName;
- schemaName = other247.schemaName;
- __isset = other247.__isset;
+TGetSchemasReq& TGetSchemasReq::operator=(const TGetSchemasReq& other263) {
+ sessionHandle = other263.sessionHandle;
+ catalogName = other263.catalogName;
+ schemaName = other263.schemaName;
+ __isset = other263.__isset;
return *this;
}
void TGetSchemasReq::printTo(std::ostream& out) const {
@@ -7249,15 +7848,15 @@ void swap(TGetSchemasResp &a, TGetSchemasResp &b) {
swap(a.__isset, b.__isset);
}
-TGetSchemasResp::TGetSchemasResp(const TGetSchemasResp& other248) {
- status = other248.status;
- operationHandle = other248.operationHandle;
- __isset = other248.__isset;
+TGetSchemasResp::TGetSchemasResp(const TGetSchemasResp& other264) {
+ status = other264.status;
+ operationHandle = other264.operationHandle;
+ __isset = other264.__isset;
}
-TGetSchemasResp& TGetSchemasResp::operator=(const TGetSchemasResp& other249) {
- status = other249.status;
- operationHandle = other249.operationHandle;
- __isset = other249.__isset;
+TGetSchemasResp& TGetSchemasResp::operator=(const TGetSchemasResp& other265) {
+ status = other265.status;
+ operationHandle = other265.operationHandle;
+ __isset = other265.__isset;
return *this;
}
void TGetSchemasResp::printTo(std::ostream& out) const {
@@ -7361,14 +7960,14 @@ uint32_t TGetTablesReq::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tableTypes.clear();
- uint32_t _size250;
- ::apache::thrift::protocol::TType _etype253;
- xfer += iprot->readListBegin(_etype253, _size250);
- this->tableTypes.resize(_size250);
- uint32_t _i254;
- for (_i254 = 0; _i254 < _size250; ++_i254)
+ uint32_t _size266;
+ ::apache::thrift::protocol::TType _etype269;
+ xfer += iprot->readListBegin(_etype269, _size266);
+ this->tableTypes.resize(_size266);
+ uint32_t _i270;
+ for (_i270 = 0; _i270 < _size266; ++_i270)
{
- xfer += iprot->readString(this->tableTypes[_i254]);
+ xfer += iprot->readString(this->tableTypes[_i270]);
}
xfer += iprot->readListEnd();
}
@@ -7419,10 +8018,10 @@ uint32_t TGetTablesReq::write(::apache::thrift::protocol::TProtocol* oprot) cons
xfer += oprot->writeFieldBegin("tableTypes", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tableTypes.size()));
- std::vector<std::string> ::const_iterator _iter255;
- for (_iter255 = this->tableTypes.begin(); _iter255 != this->tableTypes.end(); ++_iter255)
+ std::vector<std::string> ::const_iterator _iter271;
+ for (_iter271 = this->tableTypes.begin(); _iter271 != this->tableTypes.end(); ++_iter271)
{
- xfer += oprot->writeString((*_iter255));
+ xfer += oprot->writeString((*_iter271));
}
xfer += oprot->writeListEnd();
}
@@ -7443,21 +8042,21 @@ void swap(TGetTablesReq &a, TGetTablesReq &b) {
swap(a.__isset, b.__isset);
}
-TGetTablesReq::TGetTablesReq(const TGetTablesReq& other256) {
- sessionHandle = other256.sessionHandle;
- catalogName = other256.catalogName;
- schemaName = other256.schemaName;
- tableName = other256.tableName;
- tableTypes = other256.tableTypes;
- __isset = other256.__isset;
-}
-TGetTablesReq& TGetTablesReq::operator=(const TGetTablesReq& other257) {
- sessionHandle = other257.sessionHandle;
- catalogName = other257.catalogName;
- schemaName = other257.schemaName;
- tableName = other257.tableName;
- tableTypes = other257.tableTypes;
- __isset = other257.__isset;
+TGetTablesReq::TGetTablesReq(const TGetTablesReq& other272) {
+ sessionHandle = other272.sessionHandle;
+ catalogName = other272.catalogName;
+ schemaName = other272.schemaName;
+ tableName = other272.tableName;
+ tableTypes = other272.tableTypes;
+ __isset = other272.__isset;
+}
+TGetTablesReq& TGetTablesReq::operator=(const TGetTablesReq& other273) {
+ sessionHandle = other273.sessionHandle;
+ catalogName = other273.catalogName;
+ schemaName = other273.schemaName;
+ tableName = other273.tableName;
+ tableTypes = other273.tableTypes;
+ __isset = other273.__isset;
return *this;
}
void TGetTablesReq::printTo(std::ostream& out) const {
@@ -7569,15 +8168,15 @@ void swap(TGetTablesResp &a, TGetTablesResp &b) {
swap(a.__isset, b.__isset);
}
-TGetTablesResp::TGetTablesResp(const TGetTablesResp& other258) {
- status = other258.status;
- operationHandle = other258.operationHandle;
- __isset = other258.__isset;
+TGetTablesResp::TGetTablesResp(const TGetTablesResp& other274) {
+ status = other274.status;
+ operationHandle = other274.operationHandle;
+ __isset = other274.__isset;
}
-TGetTablesResp& TGetTablesResp::operator=(const TGetTablesResp& other259) {
- status = other259.status;
- operationHandle = other259.operationHandle;
- __isset = other259.__isset;
+TGetTablesResp& TGetTablesResp::operator=(const TGetTablesResp& other275) {
+ status = other275.status;
+ operationHandle = other275.operationHandle;
+ __isset = other275.__isset;
return *this;
}
void TGetTablesResp::printTo(std::ostream& out) const {
@@ -7666,11 +8265,11 @@ void swap(TGetTableTypesReq &a, TGetTableTypesReq &b) {
swap(a.sessionHandle, b.sessionHandle);
}
-TGetTableTypesReq::TGetTableTypesReq(const TGetTableTypesReq& other260) {
- sessionHandle = other260.sessionHandle;
+TGetTableTypesReq::TGetTableTypesReq(const TGetTableTypesReq& other276) {
+ sessionHandle = other276.sessionHandle;
}
-TGetTableTypesReq& TGetTableTypesReq::operator=(const TGetTableTypesReq& other261) {
- sessionHandle = other261.sessionHandle;
+TGetTableTypesReq& TGetTableTypesReq::operator=(const TGetTableTypesReq& other277) {
+ sessionHandle = other277.sessionHandle;
return *this;
}
void TGetTableTypesReq::printTo(std::ostream& out) const {
@@ -7778,15 +8377,15 @@ void swap(TGetTableTypesResp &a, TGetTableTypesResp &b) {
swap(a.__isset, b.__isset);
}
-TGetTableTypesResp::TGetTableTypesResp(const TGetTableTypesResp& other262) {
- status = other262.status;
- operationHandle = other262.operationHandle;
- __isset = other262.__isset;
+TGetTableTypesResp::TGetTableTypesResp(const TGetTableTypesResp& other278) {
+ status = other278.status;
+ operationHandle = other278.operationHandle;
+ __isset = other278.__isset;
}
-TGetTableTypesResp& TGetTableTypesResp::operator=(const TGetTableTypesResp& other263) {
- status = other263.status;
- operationHandle = other263.operationHandle;
- __isset = other263.__isset;
+TGetTableTypesResp& TGetTableTypesResp::operator=(const TGetTableTypesResp& other279) {
+ status = other279.status;
+ operationHandle = other279.operationHandle;
+ __isset = other279.__isset;
return *this;
}
void TGetTableTypesResp::printTo(std::ostream& out) const {
@@ -7952,21 +8551,21 @@ void swap(TGetColumnsReq &a, TGetColumnsReq &b) {
swap(a.__isset, b.__isset);
}
-TGetColumnsReq::TGetColumnsReq(const TGetColumnsReq& other264) {
- sessionHandle = other264.sessionHandle;
- catalogName = other264.catalogName;
- schemaName = other264.schemaName;
- tableName = other264.tableName;
- columnName = other264.columnName;
- __isset = other264.__isset;
+TGetColumnsReq::TGetColumnsReq(const TGetColumnsReq& other280) {
+ sessionHandle = other280.sessionHandle;
+ catalogName = other280.catalogName;
+ schemaName = other280.schemaName;
+ tableName = other280.tableName;
+ columnName = other280.columnName;
+ __isset = other280.__isset;
}
-TGetColumnsReq& TGetColumnsReq::operator=(const TGetColumnsReq& other265) {
- sessionHandle = other265.sessionHandle;
- catalogName = other265.catalogName;
- schemaName = other265.schemaName;
- tableName = other265.tableName;
- columnName = other265.columnName;
- __isset = other265.__isset;
+TGetColumnsReq& TGetColumnsReq::operator=(const TGetColumnsReq& other281) {
+ sessionHandle = other281.sessionHandle;
+ catalogName = other281.catalogName;
+ schemaName = other281.schemaName;
+ tableName = other281.tableName;
+ columnName = other281.columnName;
+ __isset = other281.__isset;
return *this;
}
void TGetColumnsReq::printTo(std::ostream& out) const {
@@ -8078,15 +8677,15 @@ void swap(TGetColumnsResp &a, TGetColumnsResp &b) {
swap(a.__isset, b.__isset);
}
-TGetColumnsResp::TGetColumnsResp(const TGetColumnsResp& other266) {
- status = other266.status;
- operationHandle = other266.operationHandle;
- __isset = other266.__isset;
+TGetColumnsResp::TGetColumnsResp(const TGetColumnsResp& other282) {
+ status = other282.status;
+ operationHandle = other282.operationHandle;
+ __isset = other282.__isset;
}
-TGetColumnsResp& TGetColumnsResp::operator=(const TGetColumnsResp& other267) {
- status = other267.status;
- operationHandle = other267.operationHandle;
- __isset = other267.__isset;
+TGetColumnsResp& TGetColumnsResp::operator=(const TGetColumnsResp& other283) {
+ status = other283.status;
+ operationHandle = other283.operationHandle;
+ __isset = other283.__isset;
return *this;
}
void TGetColumnsResp::printTo(std::ostream& out) const {
@@ -8234,19 +8833,19 @@ void swap(TGetFunctionsReq &a, TGetFunctionsReq &b) {
swap(a.__isset, b.__isset);
}
-TGetFunctionsReq::TGetFunctionsReq(const TGetFunctionsReq& other268) {
- sessionHandle = other268.sessionHandle;
- catalogName = other268.catalogName;
- schemaName = other268.schemaName;
- functionName = other268.functionName;
- __isset = other268.__isset;
+TGetFunctionsReq::TGetFunctionsReq(const TGetFunctionsReq& other284) {
+ sessionHandle = other284.sessionHandle;
+ catalogName = other284.catalogName;
+ schemaName = other284.schemaName;
+ functionName = other284.functionName;
+ __isset = other284.__isset;
}
-TGetFunctionsReq& TGetFunctionsReq::operator=(const TGetFunctionsReq& other269) {
- sessionHandle = other269.sessionHandle;
- catalogName = other269.catalogName;
- schemaName = other269.schemaName;
- functionName = other269.functionName;
- __isset = other269.__isset;
+TGetFunctionsReq& TGetFunctionsReq::operator=(const TGetFunctionsReq& other285) {
+ sessionHandle = other285.sessionHandle;
+ catalogName = other285.catalogName;
+ schemaName = other285.schemaName;
+ functionName = other285.functionName;
+ __isset = other285.__isset;
return *this;
}
void TGetFunctionsReq::printTo(std::ostream& out) const {
@@ -8357,15 +8956,15 @@ void swap(TGetFunctionsResp &a, TGetFunctionsResp &b) {
swap(a.__isset, b.__isset);
}
-TGetFunctionsResp::TGetFunctionsResp(const TGetFunctionsResp& other270) {
- status = other270.status;
- operationHandle = other270.operationHandle;
- __isset = other270.__isset;
+TGetFunctionsResp::TGetFunctionsResp(const TGetFunctionsResp& other286) {
+ status = other286.status;
+ operationHandle = other286.operationHandle;
+ __isset = other286.__isset;
}
-TGetFunctionsResp& TGetFunctionsResp::operator=(const TGetFunctionsResp& other271) {
- status = other271.status;
- operationHandle = other271.operationHandle;
- __isset = other271.__isset;
+TGetFunctionsResp& TGetFunctionsResp::operator=(const TGetFunctionsResp& other287) {
+ status = other287.status;
+ operationHandle = other287.operationHandle;
+ __isset = other287.__isset;
return *this;
}
void TGetFunctionsResp::printTo(std::ostream& out) const {
@@ -8512,19 +9111,19 @@ void swap(TGetPrimaryKeysReq &a, TGetPrimaryKeysReq &b) {
swap(a.__isset, b.__isset);
}
-TGetPrimaryKeysReq::TGetPrimaryKeysReq(const TGetPrimaryKeysReq& other272) {
- sessionHandle = other272.sessionHandle;
- catalogName = other272.catalogName;
- schemaName = other272.schemaName;
- tableName = other272.tableName;
- __isset = other272.__isset;
+TGetPrimaryKeysReq::TGetPrimaryKeysReq(const TGetPrimaryKeysReq& other288) {
+ sessionHandle = other288.sessionHandle;
+ catalogName = other288.catalogName;
+ schemaName = other288.schemaName;
+ tableName = other288.tableName;
+ __isset = other288.__isset;
}
-TGetPrimaryKeysReq& TGetPrimaryKeysReq::operator=(const TGetPrimaryKeysReq& other273) {
- sessionHandle = other273.sessionHandle;
- catalogName = other273.catalogName;
- schemaName = other273.schemaName;
- tableName = other273.tableName;
- __isset = other273.__isset;
+TGetPrimaryKeysReq& TGetPrimaryKeysReq::operator=(const TGetPrimaryKeysReq& other289) {
+ sessionHandle = other289.sessionHandle;
+ catalogName = other289.catalogName;
+ schemaName = other289.schemaName;
+ tableName = other289.tableName;
+ __isset = other289.__isset;
return *this;
}
void TGetPrimaryKeysReq::printTo(std::ostream& out) const {
@@ -8635,15 +9234,15 @@ void swap(TGetPrimaryKeysResp &a, TGetPrimaryKeysResp &b) {
swap(a.__isset, b.__isset);
}
-TGetPrimaryKeysResp::TGetPrimaryKeysResp(const TGetPrimaryKeysResp& other274) {
- status = other274.status;
- operationHandle = other274.operationHandle;
- __isset = other274.__isset;
+TGetPrimaryKeysResp::TGetPrimaryKeysResp(const TGetPrimaryKeysResp& other290) {
+ status = other290.status;
+ operationHandle = other290.operationHandle;
+ __isset = other290.__isset;
}
-TGetPrimaryKeysResp& TGetPrimaryKeysResp::operator=(const TGetPrimaryKeysResp& other275) {
- status = other275.status;
- operationHandle = other275.operationHandle;
- __isset = other275.__isset;
+TGetPrimaryKeysResp& TGetPrimaryKeysResp::operator=(const TGetPrimaryKeysResp& other291) {
+ status = other291.status;
+ operationHandle = other291.operationHandle;
+ __isset = other291.__isset;
return *this;
}
void TGetPrimaryKeysResp::printTo(std::ostream& out) const {
@@ -8847,25 +9446,25 @@ void swap(TGetCrossReferenceReq &a, TGetCrossReferenceReq &b) {
swap(a.__isset, b.__isset);
}
-TGetCrossReferenceReq::TGetCrossReferenceReq(const TGetCrossReferenceReq& other276) {
- sessionHandle = other276.sessionHandle;
- parentCatalogName = other276.parentCatalogName;
- parentSchemaName = other276.parentSchemaName;
- parentTableName = other276.parentTableName;
- foreignCatalogName = other276.foreignCatalogName;
- foreignSchemaName = other276.foreignSchemaName;
- foreignTableName = other276.foreignTableName;
- __isset = other276.__isset;
-}
-TGetCrossReferenceReq& TGetCrossReferenceReq::operator=(const TGetCrossReferenceReq& other277) {
- sessionHandle = other277.sessionHandle;
- parentCatalogName = other277.parentCatalogName;
- parentSchemaName = other277.parentSchemaName;
- parentTableName = other277.parentTableName;
- foreignCatalogName = other277.foreignCatalogName;
- foreignSchemaName = other277.foreignSchemaName;
- foreignTableName = other277.foreignTableName;
- __isset = other277.__isset;
+TGetCrossReferenceReq::TGetCrossReferenceReq(const TGetCrossReferenceReq& other292) {
+ sessionHandle = other292.sessionHandle;
+ parentCatalogName = other292.parentCatalogName;
+ parentSchemaName = other292.parentSchemaName;
+ parentTableName = other292.parentTableName;
+ foreignCatalogName = other292.foreignCatalogName;
+ foreignSchemaName = other292.foreignSchemaName;
+ foreignTableName = other292.foreignTableName;
+ __isset = other292.__isset;
+}
+TGetCrossReferenceReq& TGetCrossReferenceReq::operator=(const TGetCrossReferenceReq& other293) {
+ sessionHandle = other293.sessionHandle;
+ parentCatalogName = other293.parentCatalogName;
+ parentSchemaName = other293.parentSchemaName;
+ parentTableName = other293.parentTableName;
+ foreignCatalogName = other293.foreignCatalogName;
+ foreignSchemaName = other293.foreignSchemaName;
+ foreignTableName = other293.foreignTableName;
+ __isset = other293.__isset;
return *this;
}
void TGetCrossReferenceReq::printTo(std::ostream& out) const {
@@ -8979,15 +9578,15 @@ void swap(TGetCrossReferenceResp &a, TGetCrossReferenceResp &b) {
swap(a.__isset, b.__isset);
}
-TGetCrossReferenceResp::TGetCrossReferenceResp(const TGetCrossReferenceResp& other278) {
- status = other278.status;
- operationHandle = other278.operationHandle;
- __isset = other278.__isset;
+TGetCrossReferenceResp::TGetCrossReferenceResp(const TGetCrossReferenceResp& other294) {
+ status = other294.status;
+ operationHandle = other294.operationHandle;
+ __isset = other294.__isset;
}
-TGetCrossReferenceResp& TGetCrossReferenceResp::operator=(const TGetCrossReferenceResp& other279) {
- status = other279.status;
- operationHandle = other279.operationHandle;
- __isset = other279.__isset;
+TGetCrossReferenceResp& TGetCrossReferenceResp::operator=(const TGetCrossReferenceResp& other295) {
+ status = other295.status;
+ operationHandle = other295.operationHandle;
+ __isset = other295.__isset;
return *this;
}
void TGetCrossReferenceResp::printTo(std::ostream& out) const {
@@ -9096,15 +9695,15 @@ void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b) {
swap(a.__isset, b.__isset);
}
-TGetOperationStatusReq::TGetOperationStatusReq(const TGetOperationStatusReq& other280) {
- operationHandle = other280.operationHandle;
- getProgressUpdate = other280.getProgressUpdate;
- __isset = other280.__isset;
+TGetOperationStatusReq::TGetOperationStatusReq(const TGetOperationStatusReq& other296) {
+ operationHandle = other296.operationHandle;
+ getProgressUpdate = other296.getProgressUpdate;
+ __isset = other296.__isset;
}
-TGetOperationStatusReq& TGetOperationStatusReq::operator=(const TGetOperationStatusReq& other281) {
- operationHandle = other281.operationHandle;
- getProgressUpdate = other281.getProgressUpdate;
- __isset = other281.__isset;
+TGetOperationStatusReq& TGetOperationStatusReq::operator=(const TGetOperationStatusReq& other297) {
+ operationHandle = other297.operationHandle;
+ getProgressUpdate = other297.getProgressUpdate;
+ __isset = other297.__isset;
return *this;
}
void TGetOperationStatusReq::printTo(std::ostream& out) const {
@@ -9212,9 +9811,9 @@ uint32_t TGetOperationStatusResp::read(::apache::thrift::protocol::TProtocol* ip
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast282;
- xfer += iprot->readI32(ecast282);
- this->operationState = (TOperationState::type)ecast282;
+ int32_t ecast298;
+ xfer += iprot->readI32(ecast298);
+ this->operationState = (TOperationState::type)ecast298;
this->__isset.operationState = true;
} else {
xfer += iprot->skip(ftype);
@@ -9386,33 +9985,33 @@ void swap(TGetOperationStatusResp &a, TGetOperationStatusResp &b) {
swap(a.__isset, b.__isset);
}
-TGetOperationStatusResp::TGetOperationStatusResp(const TGetOperationStatusResp& other283) {
- status = other283.status;
- operationState = other283.operationState;
- sqlState = other283.sqlState;
- errorCode = other283.errorCode;
- errorMessage = other283.errorMessage;
- taskStatus = other283.taskStatus;
- operationStarted = other283.operationStarted;
- operationCompleted = other283.operationCompleted;
- hasResultSet = other283.hasResultSet;
- progressUpdateResponse = other283.progressUpdateResponse;
- numModifiedRows = other283.numModifiedRows;
- __isset = other283.__isset;
+TGetOperationStatusResp::TGetOperationStatusResp(const TGetOperationStatusResp& other299) {
+ status = other299.status;
+ operationState = other299.operationState;
+ sqlState = other299.sqlState;
+ errorCode = other299.errorCode;
+ errorMessage = other299.errorMessage;
+ taskStatus = other299.taskStatus;
+ operationStarted = other299.operationStarted;
+ operationCompleted = other299.operationCompleted;
+ hasResultSet = other299.hasResultSet;
+ progressUpdateResponse = other299.progressUpdateResponse;
+ numModifiedRows = other299.numModifiedRows;
+ __isset = other299.__isset;
}
-TGetOperationStatusResp& TGetOperationStatusResp::operator=(const TGetOperationStatusResp& other284) {
- status = other284.status;
- operationState = other284.operationState;
- sqlState = other284.sqlState;
- errorCode = other284.errorCode;
- errorMessage = other284.errorMessage;
- taskStatus = other284.taskStatus;
- operationStarted = other284.operationStarted;
- operationCompleted = other284.operationCompleted;
- hasResultSet = other284.hasResultSet;
- progressUpdateResponse = other284.progressUpdateResponse;
- numModifiedRows = other284.numModifiedRows;
- __isset = other284.__isset;
+TGetOperationStatusResp& TGetOperationStatusResp::operator=(const TGetOperationStatusResp& other300) {
+ status = other300.status;
+ operationState = other300.operationState;
+ sqlState = other300.sqlState;
+ errorCode = other300.errorCode;
+ errorMessage = other300.errorMessage;
+ taskStatus = other300.taskStatus;
+ operationStarted = other300.operationStarted;
+ operationCompleted = other300.operationCompleted;
+ hasResultSet = other300.hasResultSet;
+ progressUpdateResponse = other300.progressUpdateResponse;
+ numModifiedRows = other300.numModifiedRows;
+ __isset = other300.__isset;
return *this;
}
void TGetOperationStatusResp::printTo(std::ostream& out) const {
@@ -9510,11 +10109,11 @@ void swap(TCancelOperationReq &a, TCancelOperationReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TCancelOperationReq::TCancelOperationReq(const TCancelOperationReq& other285) {
- operationHandle = other285.operationHandle;
+TCancelOperationReq::TCancelOperationReq(const TCancelOperationReq& other301) {
+ operationHandle = other301.operationHandle;
}
-TCancelOperationReq& TCancelOperationReq::operator=(const TCancelOperationReq& other286) {
- operationHandle = other286.operationHandle;
+TCancelOperationReq& TCancelOperationReq::operator=(const TCancelOperationReq& other302) {
+ operationHandle = other302.operationHandle;
return *this;
}
void TCancelOperationReq::printTo(std::ostream& out) const {
@@ -9602,11 +10201,11 @@ void swap(TCancelOperationResp &a, TCancelOperationResp &b) {
swap(a.status, b.status);
}
-TCancelOperationResp::TCancelOperationResp(const TCancelOperationResp& other287) {
- status = other287.status;
+TCancelOperationResp::TCancelOperationResp(const TCancelOperationResp& other303) {
+ status = other303.status;
}
-TCancelOperationResp& TCancelOperationResp::operator=(const TCancelOperationResp& other288) {
- status = other288.status;
+TCancelOperationResp& TCancelOperationResp::operator=(const TCancelOperationResp& other304) {
+ status = other304.status;
return *this;
}
void TCancelOperationResp::printTo(std::ostream& out) const {
@@ -9694,11 +10293,11 @@ void swap(TCloseOperationReq &a, TCloseOperationReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TCloseOperationReq::TCloseOperationReq(const TCloseOperationReq& other289) {
- operationHandle = other289.operationHandle;
+TCloseOperationReq::TCloseOperationReq(const TCloseOperationReq& other305) {
+ operationHandle = other305.operationHandle;
}
-TCloseOperationReq& TCloseOperationReq::operator=(const TCloseOperationReq& other290) {
- operationHandle = other290.operationHandle;
+TCloseOperationReq& TCloseOperationReq::operator=(const TCloseOperationReq& other306) {
+ operationHandle = other306.operationHandle;
return *this;
}
void TCloseOperationReq::printTo(std::ostream& out) const {
@@ -9786,11 +10385,11 @@ void swap(TCloseOperationResp &a, TCloseOperationResp &b) {
swap(a.status, b.status);
}
-TCloseOperationResp::TCloseOperationResp(const TCloseOperationResp& other291) {
- status = other291.status;
+TCloseOperationResp::TCloseOperationResp(const TCloseOperationResp& other307) {
+ status = other307.status;
}
-TCloseOperationResp& TCloseOperationResp::operator=(const TCloseOperationResp& other292) {
- status = other292.status;
+TCloseOperationResp& TCloseOperationResp::operator=(const TCloseOperationResp& other308) {
+ status = other308.status;
return *this;
}
void TCloseOperationResp::printTo(std::ostream& out) const {
@@ -9878,11 +10477,11 @@ void swap(TGetResultSetMetadataReq &a, TGetResultSetMetadataReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TGetResultSetMetadataReq::TGetResultSetMetadataReq(const TGetResultSetMetadataReq& other293) {
- operationHandle = other293.operationHandle;
+TGetResultSetMetadataReq::TGetResultSetMetadataReq(const TGetResultSetMetadataReq& other309) {
+ operationHandle = other309.operationHandle;
}
-TGetResultSetMetadataReq& TGetResultSetMetadataReq::operator=(const TGetResultSetMetadataReq& other294) {
- operationHandle = other294.operationHandle;
+TGetResultSetMetadataReq& TGetResultSetMetadataReq::operator=(const TGetResultSetMetadataReq& other310) {
+ operationHandle = other310.operationHandle;
return *this;
}
void TGetResultSetMetadataReq::printTo(std::ostream& out) const {
@@ -9990,15 +10589,15 @@ void swap(TGetResultSetMetadataResp &a, TGetResultSetMetadataResp &b) {
swap(a.__isset, b.__isset);
}
-TGetResultSetMetadataResp::TGetResultSetMetadataResp(const TGetResultSetMetadataResp& other295) {
- status = other295.status;
- schema = other295.schema;
- __isset = other295.__isset;
+TGetResultSetMetadataResp::TGetResultSetMetadataResp(const TGetResultSetMetadataResp& other311) {
+ status = other311.status;
+ schema = other311.schema;
+ __isset = other311.__isset;
}
-TGetResultSetMetadataResp& TGetResultSetMetadataResp::operator=(const TGetResultSetMetadataResp& other296) {
- status = other296.status;
- schema = other296.schema;
- __isset = other296.__isset;
+TGetResultSetMetadataResp& TGetResultSetMetadataResp::operator=(const TGetResultSetMetadataResp& other312) {
+ status = other312.status;
+ schema = other312.schema;
+ __isset = other312.__isset;
return *this;
}
void TGetResultSetMetadataResp::printTo(std::ostream& out) const {
@@ -10071,9 +10670,9 @@ uint32_t TFetchResultsReq::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast297;
- xfer += iprot->readI32(ecast297);
- this->orientation = (TFetchOrientation::type)ecast297;
+ int32_t ecast313;
+ xfer += iprot->readI32(ecast313);
+ this->orientation = (TFetchOrientation::type)ecast313;
isset_orientation = true;
} else {
xfer += iprot->skip(ftype);
@@ -10149,19 +10748,19 @@ void swap(TFetchResultsReq &a, TFetchResultsReq &b) {
swap(a.__isset, b.__isset);
}
-TFetchResultsReq::TFetchResultsReq(const TFetchResultsReq& other298) {
- operationHandle = other298.operationHandle;
- orientation = other298.orientation;
- maxRows = other298.maxRows;
- fetchType = other298.fetchType;
- __isset = other298.__isset;
+TFetchResultsReq::TFetchResultsReq(const TFetchResultsReq& other314) {
+ operationHandle = other314.operationHandle;
+ orientation = other314.orientation;
+ maxRows = other314.maxRows;
+ fetchType = other314.fetchType;
+ __isset = other314.__isset;
}
-TFetchResultsReq& TFetchResultsReq::operator=(const TFetchResultsReq& other299) {
- operationHandle = other299.operationHandle;
- orientation = other299.orientation;
- maxRows = other299.maxRows;
- fetchType = other299.fetchType;
- __isset = other299.__isset;
+TFetchResultsReq& TFetchResultsReq::operator=(const TFetchResultsReq& other315) {
+ operationHandle = other315.operationHandle;
+ orientation = other315.orientation;
+ maxRows = other315.maxRows;
+ fetchType = other315.fetchType;
+ __isset = other315.__isset;
return *this;
}
void TFetchResultsReq::printTo(std::ostream& out) const {
@@ -10291,17 +10890,17 @@ void swap(TFetchResultsResp &a, TFetchResultsResp &b) {
swap(a.__isset, b.__isset);
}
-TFetchResultsResp::TFetchResultsResp(const TFetchResultsResp& other300) {
- status = other300.status;
- hasMoreRows = other300.hasMoreRows;
- results = other300.results;
- __isset = other300.__isset;
+TFetchResultsResp::TFetchResultsResp(const TFetchResultsResp& other316) {
+ status = other316.status;
+ hasMoreRows = other316.hasMoreRows;
+ results = other316.results;
+ __isset = other316.__isset;
}
-TFetchResultsResp& TFetchResultsResp::operator=(const TFetchResultsResp& other301) {
- status = other301.status;
- hasMoreRows = other301.hasMoreRows;
- results = other301.results;
- __isset = other301.__isset;
+TFetchResultsResp& TFetchResultsResp::operator=(const TFetchResultsResp& other317) {
+ status = other317.status;
+ hasMoreRows = other317.hasMoreRows;
+ results = other317.results;
+ __isset = other317.__isset;
return *this;
}
void TFetchResultsResp::printTo(std::ostream& out) const {
@@ -10431,15 +11030,15 @@ void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b) {
swap(a.renewer, b.renewer);
}
-TGetDelegationTokenReq::TGetDelegationTokenReq(const TGetDelegationTokenReq& other302) {
- sessionHandle = other302.sessionHandle;
- owner = other302.owner;
- renewer = other302.renewer;
+TGetDelegationTokenReq::TGetDelegationTokenReq(const TGetDelegationTokenReq& other318) {
+ sessionHandle = other318.sessionHandle;
+ owner = other318.owner;
+ renewer = other318.renewer;
}
-TGetDelegationTokenReq& TGetDelegationTokenReq::operator=(const TGetDelegationTokenReq& other303) {
- sessionHandle = other303.sessionHandle;
- owner = other303.owner;
- renewer = other303.renewer;
+TGetDelegationTokenReq& TGetDelegationTokenReq::operator=(const TGetDelegationTokenReq& other319) {
+ sessionHandle = other319.sessionHandle;
+ owner = other319.owner;
+ renewer = other319.renewer;
return *this;
}
void TGetDelegationTokenReq::printTo(std::ostream& out) const {
@@ -10549,15 +11148,15 @@ void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b) {
swap(a.__isset, b.__isset);
}
-TGetDelegationTokenResp::TGetDelegationTokenResp(const TGetDelegationTokenResp& other304) {
- status = other304.status;
- delegationToken = other304.delegationToken;
- __isset = other304.__isset;
+TGetDelegationTokenResp::TGetDelegationTokenResp(const TGetDelegationTokenResp& other320) {
+ status = other320.status;
+ delegationToken = other320.delegationToken;
+ __isset = other320.__isset;
}
-TGetDelegationTokenResp& TGetDelegationTokenResp::operator=(const TGetDelegationTokenResp& other305) {
- status = other305.status;
- delegationToken = other305.delegationToken;
- __isset = other305.__isset;
+TGetDelegationTokenResp& TGetDelegationTokenResp::operator=(const TGetDelegationTokenResp& other321) {
+ status = other321.status;
+ delegationToken = other321.delegationToken;
+ __isset = other321.__isset;
return *this;
}
void TGetDelegationTokenResp::printTo(std::ostream& out) const {
@@ -10666,13 +11265,13 @@ void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b) {
swap(a.delegationToken, b.delegationToken);
}
-TCancelDelegationTokenReq::TCancelDelegationTokenReq(const TCancelDelegationTokenReq& other306) {
- sessionHandle = other306.sessionHandle;
- delegationToken = other306.delegationToken;
+TCancelDelegationTokenReq::TCancelDelegationTokenReq(const TCancelDelegationTokenReq& other322) {
+ sessionHandle = other322.sessionHandle;
+ delegationToken = other322.delegationToken;
}
-TCancelDelegationTokenReq& TCancelDelegationTokenReq::operator=(const TCancelDelegationTokenReq& other307) {
- sessionHandle = other307.sessionHandle;
- delegationToken = other307.delegationToken;
+TCancelDelegationTokenReq& TCancelDelegationTokenReq::operator=(const TCancelDelegationTokenReq& other323) {
+ sessionHandle = other323.sessionHandle;
+ delegationToken = other323.delegationToken;
return *this;
}
void TCancelDelegationTokenReq::printTo(std::ostream& out) const {
@@ -10761,11 +11360,11 @@ void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b) {
swap(a.status, b.status);
}
-TCancelDelegationTokenResp::TCancelDelegationTokenResp(const TCancelDelegationTokenResp& other308) {
- status = other308.status;
+TCancelDelegationTokenResp::TCancelDelegationTokenResp(const TCancelDelegationTokenResp& other324) {
+ status = other324.status;
}
-TCancelDelegationTokenResp& TCancelDelegationTokenResp::operator=(const TCancelDelegationTokenResp& other309) {
- status = other309.status;
+TCancelDelegationTokenResp& TCancelDelegationTokenResp::operator=(const TCancelDelegationTokenResp& other325) {
+ status = other325.status;
return *this;
}
void TCancelDelegationTokenResp::printTo(std::ostream& out) const {
@@ -10873,13 +11472,13 @@ void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b) {
swap(a.delegationToken, b.delegationToken);
}
-TRenewDelegationTokenReq::TRenewDelegationTokenReq(const TRenewDelegationTokenReq& other310) {
- sessionHandle = other310.sessionHandle;
- delegationToken = other310.delegationToken;
+TRenewDelegationTokenReq::TRenewDelegationTokenReq(const TRenewDelegationTokenReq& other326) {
+ sessionHandle = other326.sessionHandle;
+ delegationToken = other326.delegationToken;
}
-TRenewDelegationTokenReq& TRenewDelegationTokenReq::operator=(const TRenewDelegationTokenReq& other311) {
- sessionHandle = other311.sessionHandle;
- delegationToken = other311.delegationToken;
+TRenewDelegationTokenReq& TRenewDelegationTokenReq::operator=(const TRenewDelegationTokenReq& other327) {
+ sessionHandle = other327.sessionHandle;
+ delegationToken = other327.delegationToken;
return *this;
}
void TRenewDelegationTokenReq::printTo(std::ostream& out) const {
@@ -10968,11 +11567,11 @@ void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b) {
swap(a.status, b.status);
}
-TRenewDelegationTokenResp::TRenewDelegationTokenResp(const TRenewDelegationTokenResp& other312) {
- status = other312.status;
+TRenewDelegationTokenResp::TRenewDelegationTokenResp(const TRenewDelegationTokenResp& other328) {
+ status = other328.status;
}
-TRenewDelegationTokenResp& TRenewDelegationTokenResp::operator=(const TRenewDelegationTokenResp& other313) {
- status = other313.status;
+TRenewDelegationTokenResp& TRenewDelegationTokenResp::operator=(const TRenewDelegationTokenResp& other329) {
+ status = other329.status;
return *this;
}
void TRenewDelegationTokenResp::printTo(std::ostream& out) const {
@@ -11048,14 +11647,14 @@ uint32_t TProgressUpdateResp::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->headerNames.clear();
- uint32_t _size314;
- ::apache::thrift::protocol::TType _etype317;
- xfer += iprot->readListBegin(_etype317, _size314);
- this->headerNames.resize(_size314);
- uint32_t _i318;
- for (_i318 = 0; _i318 < _size314; ++_i318)
+ uint32_t _size330;
+ ::apache::thrift::protocol::TType _etype333;
+ xfer += iprot->readListBegin(_etype333, _size330);
+ this->headerNames.resize(_size330);
+ uint32_t _i334;
+ for (_i334 = 0; _i334 < _size330; ++_i334)
{
- xfer += iprot->readString(this->headerNames[_i318]);
+ xfer += iprot->readString(this->headerNames[_i334]);
}
xfer += iprot->readListEnd();
}
@@ -11068,23 +11667,23 @@ uint32_t TProgressUpdateResp::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->rows.clear();
- uint32_t _size319;
- ::apache::thrift::protocol::TType _etype322;
- xfer += iprot->readListBegin(_etype322, _size319);
- this->rows.resize(_size319);
- uint32_t _i323;
- for (_i323 = 0; _i323 < _size319; ++_i323)
+ uint32_t _size335;
+ ::apache::thrift::protocol::TType _etype338;
+ xfer += iprot->readListBegin(_etype338, _size335);
+ this->rows.resize(_size335);
+ uint32_t _i339;
+ for (_i339 = 0; _i339 < _size335; ++_i339)
{
{
- this->rows[_i323].clear();
- uint32_t _size324;
- ::apache::thrift::protocol::TType _etype327;
- xfer += iprot->readListBegin(_etype327, _size324);
- this->rows[_i323].resize(_size324);
- uint32_t _i328;
- for (_i328 = 0; _i328 < _size324; ++_i328)
+ this->rows[_i339].clear();
+ uint32_t _size340;
+ ::apache::thrift::protocol::TType _etype343;
+ xfer += iprot->readListBegin(_etype343, _size340);
+ this->rows[_i339].resize(_size340);
+ uint32_t _i344;
+ for (_i344 = 0; _i344 < _size340; ++_i344)
{
- xfer += iprot->readString(this->rows[_i323][_i328]);
+ xfer += iprot->readString(this->rows[_i339][_i344]);
}
xfer += iprot->readListEnd();
}
@@ -11106,9 +11705,9 @@ uint32_t TProgressUpdateResp::read(::apache::thrift::protocol::TProtocol* iprot)
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast329;
- xfer += iprot->readI32(ecast329);
- this->status = (TJobExecutionStatus::type)ecast329;
+ int32_t ecast345;
+ xfer += iprot->readI32(ecast345);
+ this->status = (TJobExecutionStatus::type)ecast345;
isset_status = true;
} else {
xfer += iprot->skip(ftype);
@@ -11162,10 +11761,10 @@ uint32_t TProgressUpdateResp::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("headerNames", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->headerNames.size()));
- std::vector<std::string> ::const_iterator _iter330;
- for (_iter330 = this->headerNames.begin(); _iter330 != this->headerNames.end(); ++_iter330)
+ std::vector<std::string> ::const_iterator _iter346;
+ for (_iter346 = this->headerNames.begin(); _iter346 != this->headerNames.end(); ++_iter346)
{
- xfer += oprot->writeString((*_iter330));
+ xfer += oprot->writeString((*_iter346));
}
xfer += oprot->writeListEnd();
}
@@ -11174,15 +11773,15 @@ uint32_t TProgressUpdateResp::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->rows.size()));
- std::vector<std::vector<std::string> > ::const_iterator _iter331;
- for (_iter331 = this->rows.begin(); _iter331 != this->rows.end(); ++_iter331)
+ std::vector<std::vector<std::string> > ::const_iterator _iter347;
+ for (_iter347 = this->rows.begin(); _iter347 != this->rows.end(); ++_iter347)
{
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter331).size()));
- std::vector<std::string> ::const_iterator _iter332;
- for (_iter332 = (*_iter331).begin(); _iter332 != (*_iter331).end(); ++_iter332)
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter347).size()));
+ std::vector<std::string> ::const_iterator _iter348;
+ for (_iter348 = (*_iter347).begin(); _iter348 != (*_iter347).end(); ++_iter348)
{
- xfer += oprot->writeString((*_iter332));
+ xfer += oprot->writeString((*_iter348));
}
xfer += oprot->writeListEnd();
}
@@ -11222,21 +11821,21 @@ void swap(TProgressUpdateResp &a, TProgressUpdateResp &b) {
swap(a.startTime, b.startTime);
}
-TProgressUpdateResp::TProgressUpdateResp(const TProgressUpdateResp& other333) {
- headerNames = other333.headerNames;
- rows = other333.rows;
- progressedPercentage = other333.progressedPercentage;
- status = other333.status;
- footerSummary = other333.footerSummary;
- startTime = other333.startTime;
-}
-TProgressUpdateResp& TProgressUpdateResp::operator=(const TProgressUpdateResp& other334) {
- headerNames = other334.headerNames;
- rows = other334.rows;
- progressedPercentage = other334.progressedPercentage;
- status = other334.status;
- footerSummary = other334.footerSummary;
- startTime = other334.startTime;
+TProgressUpdateResp::TProgressUpdateResp(const TProgressUpdateResp& other349) {
+ headerNames = other349.headerNames;
+ rows = other349.rows;
+ progressedPercentage = other349.progressedPercentage;
+ status = other349.status;
+ footerSummary = other349.footerSummary;
+ startTime = other349.startTime;
+}
+TProgressUpdateResp& TProgressUpdateResp::operator=(const TProgressUpdateResp& other350) {
+ headerNames = other350.headerNames;
+ rows = other350.rows;
+ progressedPercentage = other350.progressedPercentage;
+ status = other350.status;
+ footerSummary = other350.footerSummary;
+ startTime = other350.startTime;
return *this;
}
void TProgressUpdateResp::printTo(std::ostream& out) const {
@@ -11329,11 +11928,11 @@ void swap(TGetQueryIdReq &a, TGetQueryIdReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TGetQueryIdReq::TGetQueryIdReq(const TGetQueryIdReq& other335) {
- operationHandle = other335.operationHandle;
+TGetQueryIdReq::TGetQueryIdReq(const TGetQueryIdReq& other351) {
+ operationHandle = other351.operationHandle;
}
-TGetQueryIdReq& TGetQueryIdReq::operator=(const TGetQueryIdReq& other336) {
- operationHandle = other336.operationHandle;
+TGetQueryIdReq& TGetQueryIdReq::operator=(const TGetQueryIdReq& other352) {
+ operationHandle = other352.operationHandle;
return *this;
}
void TGetQueryIdReq::printTo(std::ostream& out) const {
@@ -11421,11 +12020,11 @@ void swap(TGetQueryIdResp &a, TGetQueryIdResp &b) {
swap(a.queryId, b.queryId);
}
-TGetQueryIdResp::TGetQueryIdResp(const TGetQueryIdResp& other337) {
- queryId = other337.queryId;
+TGetQueryIdResp::TGetQueryIdResp(const TGetQueryIdResp& other353) {
+ queryId = other353.queryId;
}
-TGetQueryIdResp& TGetQueryIdResp::operator=(const TGetQueryIdResp& other338) {
- queryId = other338.queryId;
+TGetQueryIdResp& TGetQueryIdResp::operator=(const TGetQueryIdResp& other354) {
+ queryId = other354.queryId;
return *this;
}
void TGetQueryIdResp::printTo(std::ostream& out) const {
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
index af4094d..285bea8 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
@@ -328,6 +328,14 @@ class TGetTypeInfoReq;
class TGetTypeInfoResp;
+class TUploadDataReq;
+
+class TUploadDataResp;
+
+class TDownloadDataReq;
+
+class TDownloadDataResp;
+
class TGetCatalogsReq;
class TGetCatalogsResp;
@@ -2760,6 +2768,223 @@ void swap(TGetTypeInfoResp &a, TGetTypeInfoResp &b);
std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj);
+typedef struct _TUploadDataReq__isset {
+ _TUploadDataReq__isset() : tableName(false), path(false) {}
+ bool tableName :1;
+ bool path :1;
+} _TUploadDataReq__isset;
+
+class TUploadDataReq : public virtual ::apache::thrift::TBase {
+ public:
+
+ TUploadDataReq(const TUploadDataReq&);
+ TUploadDataReq& operator=(const TUploadDataReq&);
+ TUploadDataReq() : tableName(), path(), values() {
+ }
+
+ virtual ~TUploadDataReq() noexcept;
+ TSessionHandle sessionHandle;
+ std::string tableName;
+ std::string path;
+ std::string values;
+
+ _TUploadDataReq__isset __isset;
+
+ void __set_sessionHandle(const TSessionHandle& val);
+
+ void __set_tableName(const std::string& val);
+
+ void __set_path(const std::string& val);
+
+ void __set_values(const std::string& val);
+
+ bool operator == (const TUploadDataReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (__isset.tableName != rhs.__isset.tableName)
+ return false;
+ else if (__isset.tableName && !(tableName == rhs.tableName))
+ return false;
+ if (__isset.path != rhs.__isset.path)
+ return false;
+ else if (__isset.path && !(path == rhs.path))
+ return false;
+ if (!(values == rhs.values))
+ return false;
+ return true;
+ }
+ bool operator != (const TUploadDataReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TUploadDataReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TUploadDataReq &a, TUploadDataReq &b);
+
+std::ostream& operator<<(std::ostream& out, const TUploadDataReq& obj);
+
+
+class TUploadDataResp : public virtual ::apache::thrift::TBase {
+ public:
+
+ TUploadDataResp(const TUploadDataResp&);
+ TUploadDataResp& operator=(const TUploadDataResp&);
+ TUploadDataResp() {
+ }
+
+ virtual ~TUploadDataResp() noexcept;
+ TStatus status;
+ TOperationHandle operationHandle;
+
+ void __set_status(const TStatus& val);
+
+ void __set_operationHandle(const TOperationHandle& val);
+
+ bool operator == (const TUploadDataResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ if (!(operationHandle == rhs.operationHandle))
+ return false;
+ return true;
+ }
+ bool operator != (const TUploadDataResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TUploadDataResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TUploadDataResp &a, TUploadDataResp &b);
+
+std::ostream& operator<<(std::ostream& out, const TUploadDataResp& obj);
+
+typedef struct _TDownloadDataReq__isset {
+ _TDownloadDataReq__isset() : tableName(false), query(false), format(false), downloadOptions(false) {}
+ bool tableName :1;
+ bool query :1;
+ bool format :1;
+ bool downloadOptions :1;
+} _TDownloadDataReq__isset;
+
+class TDownloadDataReq : public virtual ::apache::thrift::TBase {
+ public:
+
+ TDownloadDataReq(const TDownloadDataReq&);
+ TDownloadDataReq& operator=(const TDownloadDataReq&);
+ TDownloadDataReq() : tableName(), query(), format() {
+ }
+
+ virtual ~TDownloadDataReq() noexcept;
+ TSessionHandle sessionHandle;
+ TPatternOrIdentifier tableName;
+ std::string query;
+ std::string format;
+ std::map<std::string, std::string> downloadOptions;
+
+ _TDownloadDataReq__isset __isset;
+
+ void __set_sessionHandle(const TSessionHandle& val);
+
+ void __set_tableName(const TPatternOrIdentifier& val);
+
+ void __set_query(const std::string& val);
+
+ void __set_format(const std::string& val);
+
+ void __set_downloadOptions(const std::map<std::string, std::string> & val);
+
+ bool operator == (const TDownloadDataReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (__isset.tableName != rhs.__isset.tableName)
+ return false;
+ else if (__isset.tableName && !(tableName == rhs.tableName))
+ return false;
+ if (__isset.query != rhs.__isset.query)
+ return false;
+ else if (__isset.query && !(query == rhs.query))
+ return false;
+ if (__isset.format != rhs.__isset.format)
+ return false;
+ else if (__isset.format && !(format == rhs.format))
+ return false;
+ if (__isset.downloadOptions != rhs.__isset.downloadOptions)
+ return false;
+ else if (__isset.downloadOptions && !(downloadOptions == rhs.downloadOptions))
+ return false;
+ return true;
+ }
+ bool operator != (const TDownloadDataReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TDownloadDataReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TDownloadDataReq &a, TDownloadDataReq &b);
+
+std::ostream& operator<<(std::ostream& out, const TDownloadDataReq& obj);
+
+
+class TDownloadDataResp : public virtual ::apache::thrift::TBase {
+ public:
+
+ TDownloadDataResp(const TDownloadDataResp&);
+ TDownloadDataResp& operator=(const TDownloadDataResp&);
+ TDownloadDataResp() {
+ }
+
+ virtual ~TDownloadDataResp() noexcept;
+ TStatus status;
+ TOperationHandle operationHandle;
+
+ void __set_status(const TStatus& val);
+
+ void __set_operationHandle(const TOperationHandle& val);
+
+ bool operator == (const TDownloadDataResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ if (!(operationHandle == rhs.operationHandle))
+ return false;
+ return true;
+ }
+ bool operator != (const TDownloadDataResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TDownloadDataResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TDownloadDataResp &a, TDownloadDataResp &b);
+
+std::ostream& operator<<(std::ostream& out, const TDownloadDataResp& obj);
+
class TGetCatalogsReq : public virtual ::apache::thrift::TBase {
public:
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
index dcb2aa6..988ad7b 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
@@ -58,6 +58,10 @@ package org.apache.hive.service.rpc.thrift;
public TSetClientInfoResp SetClientInfo(TSetClientInfoReq req) throws org.apache.thrift.TException;
+ public TUploadDataResp UploadData(TUploadDataReq req) throws org.apache.thrift.TException;
+
+ public TDownloadDataResp DownloadData(TDownloadDataReq req) throws org.apache.thrift.TException;
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public interface AsyncIface {
@@ -108,6 +112,10 @@ package org.apache.hive.service.rpc.thrift;
public void SetClientInfo(TSetClientInfoReq req, org.apache.thrift.async.AsyncMethodCallback<TSetClientInfoResp> resultHandler) throws org.apache.thrift.TException;
+ public void UploadData(TUploadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp> resultHandler) throws org.apache.thrift.TException;
+
+ public void DownloadData(TDownloadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp> resultHandler) throws org.apache.thrift.TException;
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class Client extends org.apache.thrift.TServiceClient implements Iface {
@@ -659,6 +667,52 @@ package org.apache.hive.service.rpc.thrift;
throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "SetClientInfo failed: unknown result");
}
+ public TUploadDataResp UploadData(TUploadDataReq req) throws org.apache.thrift.TException
+ {
+ send_UploadData(req);
+ return recv_UploadData();
+ }
+
+ public void send_UploadData(TUploadDataReq req) throws org.apache.thrift.TException
+ {
+ UploadData_args args = new UploadData_args();
+ args.setReq(req);
+ sendBase("UploadData", args);
+ }
+
+ public TUploadDataResp recv_UploadData() throws org.apache.thrift.TException
+ {
+ UploadData_result result = new UploadData_result();
+ receiveBase(result, "UploadData");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "UploadData failed: unknown result");
+ }
+
+ public TDownloadDataResp DownloadData(TDownloadDataReq req) throws org.apache.thrift.TException
+ {
+ send_DownloadData(req);
+ return recv_DownloadData();
+ }
+
+ public void send_DownloadData(TDownloadDataReq req) throws org.apache.thrift.TException
+ {
+ DownloadData_args args = new DownloadData_args();
+ args.setReq(req);
+ sendBase("DownloadData", args);
+ }
+
+ public TDownloadDataResp recv_DownloadData() throws org.apache.thrift.TException
+ {
+ DownloadData_result result = new DownloadData_result();
+ receiveBase(result, "DownloadData");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "DownloadData failed: unknown result");
+ }
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
@@ -1413,6 +1467,70 @@ package org.apache.hive.service.rpc.thrift;
}
}
+ public void UploadData(TUploadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ UploadData_call method_call = new UploadData_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class UploadData_call extends org.apache.thrift.async.TAsyncMethodCall<TUploadDataResp> {
+ private TUploadDataReq req;
+ public UploadData_call(TUploadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("UploadData", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ UploadData_args args = new UploadData_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TUploadDataResp getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_UploadData();
+ }
+ }
+
+ public void DownloadData(TDownloadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp> resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ DownloadData_call method_call = new DownloadData_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class DownloadData_call extends org.apache.thrift.async.TAsyncMethodCall<TDownloadDataResp> {
+ private TDownloadDataReq req;
+ public DownloadData_call(TDownloadDataReq req, org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("DownloadData", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ DownloadData_args args = new DownloadData_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TDownloadDataResp getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new java.lang.IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_DownloadData();
+ }
+ }
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
@@ -1449,6 +1567,8 @@ package org.apache.hive.service.rpc.thrift;
processMap.put("RenewDelegationToken", new RenewDelegationToken());
processMap.put("GetQueryId", new GetQueryId());
processMap.put("SetClientInfo", new SetClientInfo());
+ processMap.put("UploadData", new UploadData());
+ processMap.put("DownloadData", new DownloadData());
return processMap;
}
@@ -2027,6 +2147,56 @@ package org.apache.hive.service.rpc.thrift;
}
}
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class UploadData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, UploadData_args> {
+ public UploadData() {
+ super("UploadData");
+ }
+
+ public UploadData_args getEmptyArgsInstance() {
+ return new UploadData_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public UploadData_result getResult(I iface, UploadData_args args) throws org.apache.thrift.TException {
+ UploadData_result result = new UploadData_result();
+ result.success = iface.UploadData(args.req);
+ return result;
+ }
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class DownloadData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, DownloadData_args> {
+ public DownloadData() {
+ super("DownloadData");
+ }
+
+ public DownloadData_args getEmptyArgsInstance() {
+ return new DownloadData_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ @Override
+ protected boolean rethrowUnhandledExceptions() {
+ return false;
+ }
+
+ public DownloadData_result getResult(I iface, DownloadData_args args) throws org.apache.thrift.TException {
+ DownloadData_result result = new DownloadData_result();
+ result.success = iface.DownloadData(args.req);
+ return result;
+ }
+ }
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> {
@@ -2063,6 +2233,8 @@ package org.apache.hive.service.rpc.thrift;
processMap.put("RenewDelegationToken", new RenewDelegationToken());
processMap.put("GetQueryId", new GetQueryId());
processMap.put("SetClientInfo", new SetClientInfo());
+ processMap.put("UploadData", new UploadData());
+ processMap.put("DownloadData", new DownloadData());
return processMap;
}
@@ -3469,6 +3641,128 @@ package org.apache.hive.service.rpc.thrift;
}
}
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class UploadData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, UploadData_args, TUploadDataResp> {
+ public UploadData() {
+ super("UploadData");
+ }
+
+ public UploadData_args getEmptyArgsInstance() {
+ return new UploadData_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp>() {
+ public void onComplete(TUploadDataResp o) {
+ UploadData_result result = new UploadData_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ UploadData_result result = new UploadData_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, UploadData_args args, org.apache.thrift.async.AsyncMethodCallback<TUploadDataResp> resultHandler) throws org.apache.thrift.TException {
+ iface.UploadData(args.req,resultHandler);
+ }
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class DownloadData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, DownloadData_args, TDownloadDataResp> {
+ public DownloadData() {
+ super("DownloadData");
+ }
+
+ public DownloadData_args getEmptyArgsInstance() {
+ return new DownloadData_args();
+ }
+
+ public org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp> getResultHandler(final org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp>() {
+ public void onComplete(TDownloadDataResp o) {
+ DownloadData_result result = new DownloadData_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ } catch (org.apache.thrift.transport.TTransportException e) {
+ _LOGGER.error("TTransportException writing to internal frame buffer", e);
+ fb.close();
+ } catch (java.lang.Exception e) {
+ _LOGGER.error("Exception writing to internal frame buffer", e);
+ onError(e);
+ }
+ }
+ public void onError(java.lang.Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TSerializable msg;
+ DownloadData_result result = new DownloadData_result();
+ if (e instanceof org.apache.thrift.transport.TTransportException) {
+ _LOGGER.error("TTransportException inside handler", e);
+ fb.close();
+ return;
+ } else if (e instanceof org.apache.thrift.TApplicationException) {
+ _LOGGER.error("TApplicationException inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TApplicationException)e;
+ } else {
+ _LOGGER.error("Exception inside handler", e);
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ } catch (java.lang.Exception ex) {
+ _LOGGER.error("Exception writing to internal frame buffer", ex);
+ fb.close();
+ }
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, DownloadData_args args, org.apache.thrift.async.AsyncMethodCallback<TDownloadDataResp> resultHandler) throws org.apache.thrift.TException {
+ iface.DownloadData(args.req,resultHandler);
+ }
+ }
+
}
@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class OpenSession_args implements org.apache.thrift.TBase<OpenSession_args, OpenSession_args._Fields>, java.io.Serializable, Cloneable, Comparable<OpenSession_args> {
@@ -20353,4 +20647,1472 @@ package org.apache.hive.service.rpc.thrift;
}
}
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class UploadData_args implements org.apache.thrift.TBase<UploadData_args, UploadData_args._Fields>, java.io.Serializable, Cloneable, Comparable<UploadData_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("UploadData_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new UploadData_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new UploadData_argsTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TUploadDataReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REQ
+ return REQ;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TUploadDataReq.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(UploadData_args.class, metaDataMap);
+ }
+
+ public UploadData_args() {
+ }
+
+ public UploadData_args(
+ TUploadDataReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public UploadData_args(UploadData_args other) {
+ if (other.isSetReq()) {
+ this.req = new TUploadDataReq(other.req);
+ }
+ }
+
+ public UploadData_args deepCopy() {
+ return new UploadData_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TUploadDataReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(@org.apache.thrift.annotation.Nullable TUploadDataReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TUploadDataReq)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REQ:
+ return isSetReq();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof UploadData_args)
+ return this.equals((UploadData_args)that);
+ return false;
+ }
+
+ public boolean equals(UploadData_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetReq()) ? 131071 : 524287);
+ if (isSetReq())
+ hashCode = hashCode * 8191 + req.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(UploadData_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetReq(), other.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, other.req);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("UploadData_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (req != null) {
+ req.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class UploadData_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public UploadData_argsStandardScheme getScheme() {
+ return new UploadData_argsStandardScheme();
+ }
+ }
+
+ private static class UploadData_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<UploadData_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, UploadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TUploadDataReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, UploadData_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class UploadData_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public UploadData_argsTupleScheme getScheme() {
+ return new UploadData_argsTupleScheme();
+ }
+ }
+
+ private static class UploadData_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<UploadData_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, UploadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, UploadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TUploadDataReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class UploadData_result implements org.apache.thrift.TBase<UploadData_result, UploadData_result._Fields>, java.io.Serializable, Cloneable, Comparable<UploadData_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("UploadData_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new UploadData_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new UploadData_resultTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TUploadDataResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TUploadDataResp.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(UploadData_result.class, metaDataMap);
+ }
+
+ public UploadData_result() {
+ }
+
+ public UploadData_result(
+ TUploadDataResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public UploadData_result(UploadData_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TUploadDataResp(other.success);
+ }
+ }
+
+ public UploadData_result deepCopy() {
+ return new UploadData_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TUploadDataResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(@org.apache.thrift.annotation.Nullable TUploadDataResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TUploadDataResp)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof UploadData_result)
+ return this.equals((UploadData_result)that);
+ return false;
+ }
+
+ public boolean equals(UploadData_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(UploadData_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("UploadData_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class UploadData_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public UploadData_resultStandardScheme getScheme() {
+ return new UploadData_resultStandardScheme();
+ }
+ }
+
+ private static class UploadData_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<UploadData_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, UploadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TUploadDataResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, UploadData_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class UploadData_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public UploadData_resultTupleScheme getScheme() {
+ return new UploadData_resultTupleScheme();
+ }
+ }
+
+ private static class UploadData_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<UploadData_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, UploadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, UploadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TUploadDataResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class DownloadData_args implements org.apache.thrift.TBase<DownloadData_args, DownloadData_args._Fields>, java.io.Serializable, Cloneable, Comparable<DownloadData_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("DownloadData_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new DownloadData_argsStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new DownloadData_argsTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TDownloadDataReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REQ
+ return REQ;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDownloadDataReq.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DownloadData_args.class, metaDataMap);
+ }
+
+ public DownloadData_args() {
+ }
+
+ public DownloadData_args(
+ TDownloadDataReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public DownloadData_args(DownloadData_args other) {
+ if (other.isSetReq()) {
+ this.req = new TDownloadDataReq(other.req);
+ }
+ }
+
+ public DownloadData_args deepCopy() {
+ return new DownloadData_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TDownloadDataReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(@org.apache.thrift.annotation.Nullable TDownloadDataReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TDownloadDataReq)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REQ:
+ return isSetReq();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof DownloadData_args)
+ return this.equals((DownloadData_args)that);
+ return false;
+ }
+
+ public boolean equals(DownloadData_args that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetReq()) ? 131071 : 524287);
+ if (isSetReq())
+ hashCode = hashCode * 8191 + req.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(DownloadData_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetReq(), other.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, other.req);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("DownloadData_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (req != null) {
+ req.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class DownloadData_argsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public DownloadData_argsStandardScheme getScheme() {
+ return new DownloadData_argsStandardScheme();
+ }
+ }
+
+ private static class DownloadData_argsStandardScheme extends org.apache.thrift.scheme.StandardScheme<DownloadData_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, DownloadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TDownloadDataReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, DownloadData_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class DownloadData_argsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public DownloadData_argsTupleScheme getScheme() {
+ return new DownloadData_argsTupleScheme();
+ }
+ }
+
+ private static class DownloadData_argsTupleScheme extends org.apache.thrift.scheme.TupleScheme<DownloadData_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, DownloadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, DownloadData_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TDownloadDataReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
+ @org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public static class DownloadData_result implements org.apache.thrift.TBase<DownloadData_result, DownloadData_result._Fields>, java.io.Serializable, Cloneable, Comparable<DownloadData_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("DownloadData_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new DownloadData_resultStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new DownloadData_resultTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TDownloadDataResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TDownloadDataResp.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DownloadData_result.class, metaDataMap);
+ }
+
+ public DownloadData_result() {
+ }
+
+ public DownloadData_result(
+ TDownloadDataResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public DownloadData_result(DownloadData_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TDownloadDataResp(other.success);
+ }
+ }
+
+ public DownloadData_result deepCopy() {
+ return new DownloadData_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TDownloadDataResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(@org.apache.thrift.annotation.Nullable TDownloadDataResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TDownloadDataResp)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof DownloadData_result)
+ return this.equals((DownloadData_result)that);
+ return false;
+ }
+
+ public boolean equals(DownloadData_result that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
+ if (isSetSuccess())
+ hashCode = hashCode * 8191 + success.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(DownloadData_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetSuccess(), other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("DownloadData_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class DownloadData_resultStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public DownloadData_resultStandardScheme getScheme() {
+ return new DownloadData_resultStandardScheme();
+ }
+ }
+
+ private static class DownloadData_resultStandardScheme extends org.apache.thrift.scheme.StandardScheme<DownloadData_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, DownloadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TDownloadDataResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, DownloadData_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class DownloadData_resultTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public DownloadData_resultTupleScheme getScheme() {
+ return new DownloadData_resultTupleScheme();
+ }
+ }
+
+ private static class DownloadData_resultTupleScheme extends org.apache.thrift.scheme.TupleScheme<DownloadData_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, DownloadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet optionals = new java.util.BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, DownloadData_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ java.util.BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TDownloadDataResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+ }
+
}
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataReq.java
similarity index 59%
copy from service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
copy to service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataReq.java
index 361c950..11fa928 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataReq.java
@@ -8,31 +8,31 @@ package org.apache.hive.service.rpc.thrift;
@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)")
-@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TGetTablesReq implements org.apache.thrift.TBase<TGetTablesReq, TGetTablesReq._Fields>, java.io.Serializable, Cloneable, Comparable<TGetTablesReq> {
- private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGetTablesReq");
+@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TDownloadDataReq implements org.apache.thrift.TBase<TDownloadDataReq, TDownloadDataReq._Fields>, java.io.Serializable, Cloneable, Comparable<TDownloadDataReq> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TDownloadDataReq");
private static final org.apache.thrift.protocol.TField SESSION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("sessionHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
- private static final org.apache.thrift.protocol.TField CATALOG_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("catalogName", org.apache.thrift.protocol.TType.STRING, (short)2);
- private static final org.apache.thrift.protocol.TField SCHEMA_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("schemaName", org.apache.thrift.protocol.TType.STRING, (short)3);
- private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)4);
- private static final org.apache.thrift.protocol.TField TABLE_TYPES_FIELD_DESC = new org.apache.thrift.protocol.TField("tableTypes", org.apache.thrift.protocol.TType.LIST, (short)5);
+ private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField QUERY_FIELD_DESC = new org.apache.thrift.protocol.TField("query", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField FORMAT_FIELD_DESC = new org.apache.thrift.protocol.TField("format", org.apache.thrift.protocol.TType.STRING, (short)4);
+ private static final org.apache.thrift.protocol.TField DOWNLOAD_OPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("downloadOptions", org.apache.thrift.protocol.TType.MAP, (short)5);
- private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TGetTablesReqStandardSchemeFactory();
- private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TGetTablesReqTupleSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TDownloadDataReqStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TDownloadDataReqTupleSchemeFactory();
private @org.apache.thrift.annotation.Nullable TSessionHandle sessionHandle; // required
- private @org.apache.thrift.annotation.Nullable java.lang.String catalogName; // optional
- private @org.apache.thrift.annotation.Nullable java.lang.String schemaName; // optional
private @org.apache.thrift.annotation.Nullable java.lang.String tableName; // optional
- private @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> tableTypes; // optional
+ private @org.apache.thrift.annotation.Nullable java.lang.String query; // optional
+ private @org.apache.thrift.annotation.Nullable java.lang.String format; // optional
+ private @org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> downloadOptions; // optional
/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
public enum _Fields implements org.apache.thrift.TFieldIdEnum {
SESSION_HANDLE((short)1, "sessionHandle"),
- CATALOG_NAME((short)2, "catalogName"),
- SCHEMA_NAME((short)3, "schemaName"),
- TABLE_NAME((short)4, "tableName"),
- TABLE_TYPES((short)5, "tableTypes");
+ TABLE_NAME((short)2, "tableName"),
+ QUERY((short)3, "query"),
+ FORMAT((short)4, "format"),
+ DOWNLOAD_OPTIONS((short)5, "downloadOptions");
private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
@@ -50,14 +50,14 @@ package org.apache.hive.service.rpc.thrift;
switch(fieldId) {
case 1: // SESSION_HANDLE
return SESSION_HANDLE;
- case 2: // CATALOG_NAME
- return CATALOG_NAME;
- case 3: // SCHEMA_NAME
- return SCHEMA_NAME;
- case 4: // TABLE_NAME
+ case 2: // TABLE_NAME
return TABLE_NAME;
- case 5: // TABLE_TYPES
- return TABLE_TYPES;
+ case 3: // QUERY
+ return QUERY;
+ case 4: // FORMAT
+ return FORMAT;
+ case 5: // DOWNLOAD_OPTIONS
+ return DOWNLOAD_OPTIONS;
default:
return null;
}
@@ -99,29 +99,30 @@ package org.apache.hive.service.rpc.thrift;
}
// isset id assignments
- private static final _Fields optionals[] = {_Fields.CATALOG_NAME,_Fields.SCHEMA_NAME,_Fields.TABLE_NAME,_Fields.TABLE_TYPES};
+ private static final _Fields optionals[] = {_Fields.TABLE_NAME,_Fields.QUERY,_Fields.FORMAT,_Fields.DOWNLOAD_OPTIONS};
public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
static {
java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
tmpMap.put(_Fields.SESSION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("sessionHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSessionHandle.class)));
- tmpMap.put(_Fields.CATALOG_NAME, new org.apache.thrift.meta_data.FieldMetaData("catalogName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
- tmpMap.put(_Fields.SCHEMA_NAME, new org.apache.thrift.meta_data.FieldMetaData("schemaName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
- tmpMap.put(_Fields.TABLE_TYPES, new org.apache.thrift.meta_data.FieldMetaData("tableTypes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ tmpMap.put(_Fields.QUERY, new org.apache.thrift.meta_data.FieldMetaData("query", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.FORMAT, new org.apache.thrift.meta_data.FieldMetaData("format", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.DOWNLOAD_OPTIONS, new org.apache.thrift.meta_data.FieldMetaData("downloadOptions", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
- org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetTablesReq.class, metaDataMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TDownloadDataReq.class, metaDataMap);
}
- public TGetTablesReq() {
+ public TDownloadDataReq() {
}
- public TGetTablesReq(
+ public TDownloadDataReq(
TSessionHandle sessionHandle)
{
this();
@@ -131,36 +132,36 @@ package org.apache.hive.service.rpc.thrift;
/**
* Performs a deep copy on <i>other</i>.
*/
- public TGetTablesReq(TGetTablesReq other) {
+ public TDownloadDataReq(TDownloadDataReq other) {
if (other.isSetSessionHandle()) {
this.sessionHandle = new TSessionHandle(other.sessionHandle);
}
- if (other.isSetCatalogName()) {
- this.catalogName = other.catalogName;
- }
- if (other.isSetSchemaName()) {
- this.schemaName = other.schemaName;
- }
if (other.isSetTableName()) {
this.tableName = other.tableName;
}
- if (other.isSetTableTypes()) {
- java.util.List<java.lang.String> __this__tableTypes = new java.util.ArrayList<java.lang.String>(other.tableTypes);
- this.tableTypes = __this__tableTypes;
+ if (other.isSetQuery()) {
+ this.query = other.query;
+ }
+ if (other.isSetFormat()) {
+ this.format = other.format;
+ }
+ if (other.isSetDownloadOptions()) {
+ java.util.Map<java.lang.String,java.lang.String> __this__downloadOptions = new java.util.HashMap<java.lang.String,java.lang.String>(other.downloadOptions);
+ this.downloadOptions = __this__downloadOptions;
}
}
- public TGetTablesReq deepCopy() {
- return new TGetTablesReq(this);
+ public TDownloadDataReq deepCopy() {
+ return new TDownloadDataReq(this);
}
@Override
public void clear() {
this.sessionHandle = null;
- this.catalogName = null;
- this.schemaName = null;
this.tableName = null;
- this.tableTypes = null;
+ this.query = null;
+ this.format = null;
+ this.downloadOptions = null;
}
@org.apache.thrift.annotation.Nullable
@@ -188,114 +189,109 @@ package org.apache.hive.service.rpc.thrift;
}
@org.apache.thrift.annotation.Nullable
- public java.lang.String getCatalogName() {
- return this.catalogName;
+ public java.lang.String getTableName() {
+ return this.tableName;
}
- public void setCatalogName(@org.apache.thrift.annotation.Nullable java.lang.String catalogName) {
- this.catalogName = catalogName;
+ public void setTableName(@org.apache.thrift.annotation.Nullable java.lang.String tableName) {
+ this.tableName = tableName;
}
- public void unsetCatalogName() {
- this.catalogName = null;
+ public void unsetTableName() {
+ this.tableName = null;
}
- /** Returns true if field catalogName is set (has been assigned a value) and false otherwise */
- public boolean isSetCatalogName() {
- return this.catalogName != null;
+ /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTableName() {
+ return this.tableName != null;
}
- public void setCatalogNameIsSet(boolean value) {
+ public void setTableNameIsSet(boolean value) {
if (!value) {
- this.catalogName = null;
+ this.tableName = null;
}
}
@org.apache.thrift.annotation.Nullable
- public java.lang.String getSchemaName() {
- return this.schemaName;
+ public java.lang.String getQuery() {
+ return this.query;
}
- public void setSchemaName(@org.apache.thrift.annotation.Nullable java.lang.String schemaName) {
- this.schemaName = schemaName;
+ public void setQuery(@org.apache.thrift.annotation.Nullable java.lang.String query) {
+ this.query = query;
}
- public void unsetSchemaName() {
- this.schemaName = null;
+ public void unsetQuery() {
+ this.query = null;
}
- /** Returns true if field schemaName is set (has been assigned a value) and false otherwise */
- public boolean isSetSchemaName() {
- return this.schemaName != null;
+ /** Returns true if field query is set (has been assigned a value) and false otherwise */
+ public boolean isSetQuery() {
+ return this.query != null;
}
- public void setSchemaNameIsSet(boolean value) {
+ public void setQueryIsSet(boolean value) {
if (!value) {
- this.schemaName = null;
+ this.query = null;
}
}
@org.apache.thrift.annotation.Nullable
- public java.lang.String getTableName() {
- return this.tableName;
+ public java.lang.String getFormat() {
+ return this.format;
}
- public void setTableName(@org.apache.thrift.annotation.Nullable java.lang.String tableName) {
- this.tableName = tableName;
+ public void setFormat(@org.apache.thrift.annotation.Nullable java.lang.String format) {
+ this.format = format;
}
- public void unsetTableName() {
- this.tableName = null;
+ public void unsetFormat() {
+ this.format = null;
}
- /** Returns true if field tableName is set (has been assigned a value) and false otherwise */
- public boolean isSetTableName() {
- return this.tableName != null;
+ /** Returns true if field format is set (has been assigned a value) and false otherwise */
+ public boolean isSetFormat() {
+ return this.format != null;
}
- public void setTableNameIsSet(boolean value) {
+ public void setFormatIsSet(boolean value) {
if (!value) {
- this.tableName = null;
+ this.format = null;
}
}
- public int getTableTypesSize() {
- return (this.tableTypes == null) ? 0 : this.tableTypes.size();
- }
-
- @org.apache.thrift.annotation.Nullable
- public java.util.Iterator<java.lang.String> getTableTypesIterator() {
- return (this.tableTypes == null) ? null : this.tableTypes.iterator();
+ public int getDownloadOptionsSize() {
+ return (this.downloadOptions == null) ? 0 : this.downloadOptions.size();
}
- public void addToTableTypes(java.lang.String elem) {
- if (this.tableTypes == null) {
- this.tableTypes = new java.util.ArrayList<java.lang.String>();
+ public void putToDownloadOptions(java.lang.String key, java.lang.String val) {
+ if (this.downloadOptions == null) {
+ this.downloadOptions = new java.util.HashMap<java.lang.String,java.lang.String>();
}
- this.tableTypes.add(elem);
+ this.downloadOptions.put(key, val);
}
@org.apache.thrift.annotation.Nullable
- public java.util.List<java.lang.String> getTableTypes() {
- return this.tableTypes;
+ public java.util.Map<java.lang.String,java.lang.String> getDownloadOptions() {
+ return this.downloadOptions;
}
- public void setTableTypes(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> tableTypes) {
- this.tableTypes = tableTypes;
+ public void setDownloadOptions(@org.apache.thrift.annotation.Nullable java.util.Map<java.lang.String,java.lang.String> downloadOptions) {
+ this.downloadOptions = downloadOptions;
}
- public void unsetTableTypes() {
- this.tableTypes = null;
+ public void unsetDownloadOptions() {
+ this.downloadOptions = null;
}
- /** Returns true if field tableTypes is set (has been assigned a value) and false otherwise */
- public boolean isSetTableTypes() {
- return this.tableTypes != null;
+ /** Returns true if field downloadOptions is set (has been assigned a value) and false otherwise */
+ public boolean isSetDownloadOptions() {
+ return this.downloadOptions != null;
}
- public void setTableTypesIsSet(boolean value) {
+ public void setDownloadOptionsIsSet(boolean value) {
if (!value) {
- this.tableTypes = null;
+ this.downloadOptions = null;
}
}
@@ -309,35 +305,35 @@ package org.apache.hive.service.rpc.thrift;
}
break;
- case CATALOG_NAME:
+ case TABLE_NAME:
if (value == null) {
- unsetCatalogName();
+ unsetTableName();
} else {
- setCatalogName((java.lang.String)value);
+ setTableName((java.lang.String)value);
}
break;
- case SCHEMA_NAME:
+ case QUERY:
if (value == null) {
- unsetSchemaName();
+ unsetQuery();
} else {
- setSchemaName((java.lang.String)value);
+ setQuery((java.lang.String)value);
}
break;
- case TABLE_NAME:
+ case FORMAT:
if (value == null) {
- unsetTableName();
+ unsetFormat();
} else {
- setTableName((java.lang.String)value);
+ setFormat((java.lang.String)value);
}
break;
- case TABLE_TYPES:
+ case DOWNLOAD_OPTIONS:
if (value == null) {
- unsetTableTypes();
+ unsetDownloadOptions();
} else {
- setTableTypes((java.util.List<java.lang.String>)value);
+ setDownloadOptions((java.util.Map<java.lang.String,java.lang.String>)value);
}
break;
@@ -350,17 +346,17 @@ package org.apache.hive.service.rpc.thrift;
case SESSION_HANDLE:
return getSessionHandle();
- case CATALOG_NAME:
- return getCatalogName();
-
- case SCHEMA_NAME:
- return getSchemaName();
-
case TABLE_NAME:
return getTableName();
- case TABLE_TYPES:
- return getTableTypes();
+ case QUERY:
+ return getQuery();
+
+ case FORMAT:
+ return getFormat();
+
+ case DOWNLOAD_OPTIONS:
+ return getDownloadOptions();
}
throw new java.lang.IllegalStateException();
@@ -375,26 +371,26 @@ package org.apache.hive.service.rpc.thrift;
switch (field) {
case SESSION_HANDLE:
return isSetSessionHandle();
- case CATALOG_NAME:
- return isSetCatalogName();
- case SCHEMA_NAME:
- return isSetSchemaName();
case TABLE_NAME:
return isSetTableName();
- case TABLE_TYPES:
- return isSetTableTypes();
+ case QUERY:
+ return isSetQuery();
+ case FORMAT:
+ return isSetFormat();
+ case DOWNLOAD_OPTIONS:
+ return isSetDownloadOptions();
}
throw new java.lang.IllegalStateException();
}
@Override
public boolean equals(java.lang.Object that) {
- if (that instanceof TGetTablesReq)
- return this.equals((TGetTablesReq)that);
+ if (that instanceof TDownloadDataReq)
+ return this.equals((TDownloadDataReq)that);
return false;
}
- public boolean equals(TGetTablesReq that) {
+ public boolean equals(TDownloadDataReq that) {
if (that == null)
return false;
if (this == that)
@@ -409,39 +405,39 @@ package org.apache.hive.service.rpc.thrift;
return false;
}
- boolean this_present_catalogName = true && this.isSetCatalogName();
- boolean that_present_catalogName = true && that.isSetCatalogName();
- if (this_present_catalogName || that_present_catalogName) {
- if (!(this_present_catalogName && that_present_catalogName))
+ boolean this_present_tableName = true && this.isSetTableName();
+ boolean that_present_tableName = true && that.isSetTableName();
+ if (this_present_tableName || that_present_tableName) {
+ if (!(this_present_tableName && that_present_tableName))
return false;
- if (!this.catalogName.equals(that.catalogName))
+ if (!this.tableName.equals(that.tableName))
return false;
}
- boolean this_present_schemaName = true && this.isSetSchemaName();
- boolean that_present_schemaName = true && that.isSetSchemaName();
- if (this_present_schemaName || that_present_schemaName) {
- if (!(this_present_schemaName && that_present_schemaName))
+ boolean this_present_query = true && this.isSetQuery();
+ boolean that_present_query = true && that.isSetQuery();
+ if (this_present_query || that_present_query) {
+ if (!(this_present_query && that_present_query))
return false;
- if (!this.schemaName.equals(that.schemaName))
+ if (!this.query.equals(that.query))
return false;
}
- boolean this_present_tableName = true && this.isSetTableName();
- boolean that_present_tableName = true && that.isSetTableName();
- if (this_present_tableName || that_present_tableName) {
- if (!(this_present_tableName && that_present_tableName))
+ boolean this_present_format = true && this.isSetFormat();
+ boolean that_present_format = true && that.isSetFormat();
+ if (this_present_format || that_present_format) {
+ if (!(this_present_format && that_present_format))
return false;
- if (!this.tableName.equals(that.tableName))
+ if (!this.format.equals(that.format))
return false;
}
- boolean this_present_tableTypes = true && this.isSetTableTypes();
- boolean that_present_tableTypes = true && that.isSetTableTypes();
- if (this_present_tableTypes || that_present_tableTypes) {
- if (!(this_present_tableTypes && that_present_tableTypes))
+ boolean this_present_downloadOptions = true && this.isSetDownloadOptions();
+ boolean that_present_downloadOptions = true && that.isSetDownloadOptions();
+ if (this_present_downloadOptions || that_present_downloadOptions) {
+ if (!(this_present_downloadOptions && that_present_downloadOptions))
return false;
- if (!this.tableTypes.equals(that.tableTypes))
+ if (!this.downloadOptions.equals(that.downloadOptions))
return false;
}
@@ -456,27 +452,27 @@ package org.apache.hive.service.rpc.thrift;
if (isSetSessionHandle())
hashCode = hashCode * 8191 + sessionHandle.hashCode();
- hashCode = hashCode * 8191 + ((isSetCatalogName()) ? 131071 : 524287);
- if (isSetCatalogName())
- hashCode = hashCode * 8191 + catalogName.hashCode();
-
- hashCode = hashCode * 8191 + ((isSetSchemaName()) ? 131071 : 524287);
- if (isSetSchemaName())
- hashCode = hashCode * 8191 + schemaName.hashCode();
-
hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
if (isSetTableName())
hashCode = hashCode * 8191 + tableName.hashCode();
- hashCode = hashCode * 8191 + ((isSetTableTypes()) ? 131071 : 524287);
- if (isSetTableTypes())
- hashCode = hashCode * 8191 + tableTypes.hashCode();
+ hashCode = hashCode * 8191 + ((isSetQuery()) ? 131071 : 524287);
+ if (isSetQuery())
+ hashCode = hashCode * 8191 + query.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetFormat()) ? 131071 : 524287);
+ if (isSetFormat())
+ hashCode = hashCode * 8191 + format.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetDownloadOptions()) ? 131071 : 524287);
+ if (isSetDownloadOptions())
+ hashCode = hashCode * 8191 + downloadOptions.hashCode();
return hashCode;
}
@Override
- public int compareTo(TGetTablesReq other) {
+ public int compareTo(TDownloadDataReq other) {
if (!getClass().equals(other.getClass())) {
return getClass().getName().compareTo(other.getClass().getName());
}
@@ -493,42 +489,42 @@ package org.apache.hive.service.rpc.thrift;
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetCatalogName(), other.isSetCatalogName());
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetCatalogName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.catalogName, other.catalogName);
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
if (lastComparison != 0) {
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetSchemaName(), other.isSetSchemaName());
+ lastComparison = java.lang.Boolean.compare(isSetQuery(), other.isSetQuery());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetSchemaName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.schemaName, other.schemaName);
+ if (isSetQuery()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.query, other.query);
if (lastComparison != 0) {
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ lastComparison = java.lang.Boolean.compare(isSetFormat(), other.isSetFormat());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetTableName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
+ if (isSetFormat()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format, other.format);
if (lastComparison != 0) {
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetTableTypes(), other.isSetTableTypes());
+ lastComparison = java.lang.Boolean.compare(isSetDownloadOptions(), other.isSetDownloadOptions());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetTableTypes()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableTypes, other.tableTypes);
+ if (isSetDownloadOptions()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.downloadOptions, other.downloadOptions);
if (lastComparison != 0) {
return lastComparison;
}
@@ -551,7 +547,7 @@ package org.apache.hive.service.rpc.thrift;
@Override
public java.lang.String toString() {
- java.lang.StringBuilder sb = new java.lang.StringBuilder("TGetTablesReq(");
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TDownloadDataReq(");
boolean first = true;
sb.append("sessionHandle:");
@@ -561,43 +557,43 @@ package org.apache.hive.service.rpc.thrift;
sb.append(this.sessionHandle);
}
first = false;
- if (isSetCatalogName()) {
+ if (isSetTableName()) {
if (!first) sb.append(", ");
- sb.append("catalogName:");
- if (this.catalogName == null) {
+ sb.append("tableName:");
+ if (this.tableName == null) {
sb.append("null");
} else {
- sb.append(this.catalogName);
+ sb.append(this.tableName);
}
first = false;
}
- if (isSetSchemaName()) {
+ if (isSetQuery()) {
if (!first) sb.append(", ");
- sb.append("schemaName:");
- if (this.schemaName == null) {
+ sb.append("query:");
+ if (this.query == null) {
sb.append("null");
} else {
- sb.append(this.schemaName);
+ sb.append(this.query);
}
first = false;
}
- if (isSetTableName()) {
+ if (isSetFormat()) {
if (!first) sb.append(", ");
- sb.append("tableName:");
- if (this.tableName == null) {
+ sb.append("format:");
+ if (this.format == null) {
sb.append("null");
} else {
- sb.append(this.tableName);
+ sb.append(this.format);
}
first = false;
}
- if (isSetTableTypes()) {
+ if (isSetDownloadOptions()) {
if (!first) sb.append(", ");
- sb.append("tableTypes:");
- if (this.tableTypes == null) {
+ sb.append("downloadOptions:");
+ if (this.downloadOptions == null) {
sb.append("null");
} else {
- sb.append(this.tableTypes);
+ sb.append(this.downloadOptions);
}
first = false;
}
@@ -633,15 +629,15 @@ package org.apache.hive.service.rpc.thrift;
}
}
- private static class TGetTablesReqStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
- public TGetTablesReqStandardScheme getScheme() {
- return new TGetTablesReqStandardScheme();
+ private static class TDownloadDataReqStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDownloadDataReqStandardScheme getScheme() {
+ return new TDownloadDataReqStandardScheme();
}
}
- private static class TGetTablesReqStandardScheme extends org.apache.thrift.scheme.StandardScheme<TGetTablesReq> {
+ private static class TDownloadDataReqStandardScheme extends org.apache.thrift.scheme.StandardScheme<TDownloadDataReq> {
- public void read(org.apache.thrift.protocol.TProtocol iprot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TDownloadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TField schemeField;
iprot.readStructBegin();
while (true)
@@ -660,44 +656,46 @@ package org.apache.hive.service.rpc.thrift;
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 2: // CATALOG_NAME
+ case 2: // TABLE_NAME
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.catalogName = iprot.readString();
- struct.setCatalogNameIsSet(true);
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 3: // SCHEMA_NAME
+ case 3: // QUERY
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.schemaName = iprot.readString();
- struct.setSchemaNameIsSet(true);
+ struct.query = iprot.readString();
+ struct.setQueryIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 4: // TABLE_NAME
+ case 4: // FORMAT
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.tableName = iprot.readString();
- struct.setTableNameIsSet(true);
+ struct.format = iprot.readString();
+ struct.setFormatIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 5: // TABLE_TYPES
- if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ case 5: // DOWNLOAD_OPTIONS
+ if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
{
- org.apache.thrift.protocol.TList _list182 = iprot.readListBegin();
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list182.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem183;
- for (int _i184 = 0; _i184 < _list182.size; ++_i184)
+ org.apache.thrift.protocol.TMap _map182 = iprot.readMapBegin();
+ struct.downloadOptions = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map182.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key183;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val184;
+ for (int _i185 = 0; _i185 < _map182.size; ++_i185)
{
- _elem183 = iprot.readString();
- struct.tableTypes.add(_elem183);
+ _key183 = iprot.readString();
+ _val184 = iprot.readString();
+ struct.downloadOptions.put(_key183, _val184);
}
- iprot.readListEnd();
+ iprot.readMapEnd();
}
- struct.setTableTypesIsSet(true);
+ struct.setDownloadOptionsIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
@@ -711,7 +709,7 @@ package org.apache.hive.service.rpc.thrift;
struct.validate();
}
- public void write(org.apache.thrift.protocol.TProtocol oprot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TDownloadDataReq struct) throws org.apache.thrift.TException {
struct.validate();
oprot.writeStructBegin(STRUCT_DESC);
@@ -720,37 +718,38 @@ package org.apache.hive.service.rpc.thrift;
struct.sessionHandle.write(oprot);
oprot.writeFieldEnd();
}
- if (struct.catalogName != null) {
- if (struct.isSetCatalogName()) {
- oprot.writeFieldBegin(CATALOG_NAME_FIELD_DESC);
- oprot.writeString(struct.catalogName);
+ if (struct.tableName != null) {
+ if (struct.isSetTableName()) {
+ oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
+ oprot.writeString(struct.tableName);
oprot.writeFieldEnd();
}
}
- if (struct.schemaName != null) {
- if (struct.isSetSchemaName()) {
- oprot.writeFieldBegin(SCHEMA_NAME_FIELD_DESC);
- oprot.writeString(struct.schemaName);
+ if (struct.query != null) {
+ if (struct.isSetQuery()) {
+ oprot.writeFieldBegin(QUERY_FIELD_DESC);
+ oprot.writeString(struct.query);
oprot.writeFieldEnd();
}
}
- if (struct.tableName != null) {
- if (struct.isSetTableName()) {
- oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
- oprot.writeString(struct.tableName);
+ if (struct.format != null) {
+ if (struct.isSetFormat()) {
+ oprot.writeFieldBegin(FORMAT_FIELD_DESC);
+ oprot.writeString(struct.format);
oprot.writeFieldEnd();
}
}
- if (struct.tableTypes != null) {
- if (struct.isSetTableTypes()) {
- oprot.writeFieldBegin(TABLE_TYPES_FIELD_DESC);
+ if (struct.downloadOptions != null) {
+ if (struct.isSetDownloadOptions()) {
+ oprot.writeFieldBegin(DOWNLOAD_OPTIONS_FIELD_DESC);
{
- oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tableTypes.size()));
- for (java.lang.String _iter185 : struct.tableTypes)
+ oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.downloadOptions.size()));
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter186 : struct.downloadOptions.entrySet())
{
- oprot.writeString(_iter185);
+ oprot.writeString(_iter186.getKey());
+ oprot.writeString(_iter186.getValue());
}
- oprot.writeListEnd();
+ oprot.writeMapEnd();
}
oprot.writeFieldEnd();
}
@@ -761,83 +760,86 @@ package org.apache.hive.service.rpc.thrift;
}
- private static class TGetTablesReqTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
- public TGetTablesReqTupleScheme getScheme() {
- return new TGetTablesReqTupleScheme();
+ private static class TDownloadDataReqTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDownloadDataReqTupleScheme getScheme() {
+ return new TDownloadDataReqTupleScheme();
}
}
- private static class TGetTablesReqTupleScheme extends org.apache.thrift.scheme.TupleScheme<TGetTablesReq> {
+ private static class TDownloadDataReqTupleScheme extends org.apache.thrift.scheme.TupleScheme<TDownloadDataReq> {
@Override
- public void write(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void write(org.apache.thrift.protocol.TProtocol prot, TDownloadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
struct.sessionHandle.write(oprot);
java.util.BitSet optionals = new java.util.BitSet();
- if (struct.isSetCatalogName()) {
+ if (struct.isSetTableName()) {
optionals.set(0);
}
- if (struct.isSetSchemaName()) {
+ if (struct.isSetQuery()) {
optionals.set(1);
}
- if (struct.isSetTableName()) {
+ if (struct.isSetFormat()) {
optionals.set(2);
}
- if (struct.isSetTableTypes()) {
+ if (struct.isSetDownloadOptions()) {
optionals.set(3);
}
oprot.writeBitSet(optionals, 4);
- if (struct.isSetCatalogName()) {
- oprot.writeString(struct.catalogName);
- }
- if (struct.isSetSchemaName()) {
- oprot.writeString(struct.schemaName);
- }
if (struct.isSetTableName()) {
oprot.writeString(struct.tableName);
}
- if (struct.isSetTableTypes()) {
+ if (struct.isSetQuery()) {
+ oprot.writeString(struct.query);
+ }
+ if (struct.isSetFormat()) {
+ oprot.writeString(struct.format);
+ }
+ if (struct.isSetDownloadOptions()) {
{
- oprot.writeI32(struct.tableTypes.size());
- for (java.lang.String _iter186 : struct.tableTypes)
+ oprot.writeI32(struct.downloadOptions.size());
+ for (java.util.Map.Entry<java.lang.String, java.lang.String> _iter187 : struct.downloadOptions.entrySet())
{
- oprot.writeString(_iter186);
+ oprot.writeString(_iter187.getKey());
+ oprot.writeString(_iter187.getValue());
}
}
}
}
@Override
- public void read(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void read(org.apache.thrift.protocol.TProtocol prot, TDownloadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
struct.sessionHandle = new TSessionHandle();
struct.sessionHandle.read(iprot);
struct.setSessionHandleIsSet(true);
java.util.BitSet incoming = iprot.readBitSet(4);
if (incoming.get(0)) {
- struct.catalogName = iprot.readString();
- struct.setCatalogNameIsSet(true);
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
}
if (incoming.get(1)) {
- struct.schemaName = iprot.readString();
- struct.setSchemaNameIsSet(true);
+ struct.query = iprot.readString();
+ struct.setQueryIsSet(true);
}
if (incoming.get(2)) {
- struct.tableName = iprot.readString();
- struct.setTableNameIsSet(true);
+ struct.format = iprot.readString();
+ struct.setFormatIsSet(true);
}
if (incoming.get(3)) {
{
- org.apache.thrift.protocol.TList _list187 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list187.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem188;
- for (int _i189 = 0; _i189 < _list187.size; ++_i189)
+ org.apache.thrift.protocol.TMap _map188 = iprot.readMapBegin(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING);
+ struct.downloadOptions = new java.util.HashMap<java.lang.String,java.lang.String>(2*_map188.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _key189;
+ @org.apache.thrift.annotation.Nullable java.lang.String _val190;
+ for (int _i191 = 0; _i191 < _map188.size; ++_i191)
{
- _elem188 = iprot.readString();
- struct.tableTypes.add(_elem188);
+ _key189 = iprot.readString();
+ _val190 = iprot.readString();
+ struct.downloadOptions.put(_key189, _val190);
}
}
- struct.setTableTypesIsSet(true);
+ struct.setDownloadOptionsIsSet(true);
}
}
}
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataResp.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataResp.java
new file mode 100644
index 0000000..0f3109d
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TDownloadDataResp.java
@@ -0,0 +1,477 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.rpc.thrift;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)")
+@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TDownloadDataResp implements org.apache.thrift.TBase<TDownloadDataResp, TDownloadDataResp._Fields>, java.io.Serializable, Cloneable, Comparable<TDownloadDataResp> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TDownloadDataResp");
+
+ private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField OPERATION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("operationHandle", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TDownloadDataRespStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TDownloadDataRespTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TStatus status; // required
+ private @org.apache.thrift.annotation.Nullable TOperationHandle operationHandle; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ STATUS((short)1, "status"),
+ OPERATION_HANDLE((short)2, "operationHandle");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // STATUS
+ return STATUS;
+ case 2: // OPERATION_HANDLE
+ return OPERATION_HANDLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TStatus.class)));
+ tmpMap.put(_Fields.OPERATION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("operationHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TOperationHandle.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TDownloadDataResp.class, metaDataMap);
+ }
+
+ public TDownloadDataResp() {
+ }
+
+ public TDownloadDataResp(
+ TStatus status,
+ TOperationHandle operationHandle)
+ {
+ this();
+ this.status = status;
+ this.operationHandle = operationHandle;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TDownloadDataResp(TDownloadDataResp other) {
+ if (other.isSetStatus()) {
+ this.status = new TStatus(other.status);
+ }
+ if (other.isSetOperationHandle()) {
+ this.operationHandle = new TOperationHandle(other.operationHandle);
+ }
+ }
+
+ public TDownloadDataResp deepCopy() {
+ return new TDownloadDataResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.status = null;
+ this.operationHandle = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TStatus getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(@org.apache.thrift.annotation.Nullable TStatus status) {
+ this.status = status;
+ }
+
+ public void unsetStatus() {
+ this.status = null;
+ }
+
+ /** Returns true if field status is set (has been assigned a value) and false otherwise */
+ public boolean isSetStatus() {
+ return this.status != null;
+ }
+
+ public void setStatusIsSet(boolean value) {
+ if (!value) {
+ this.status = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TOperationHandle getOperationHandle() {
+ return this.operationHandle;
+ }
+
+ public void setOperationHandle(@org.apache.thrift.annotation.Nullable TOperationHandle operationHandle) {
+ this.operationHandle = operationHandle;
+ }
+
+ public void unsetOperationHandle() {
+ this.operationHandle = null;
+ }
+
+ /** Returns true if field operationHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetOperationHandle() {
+ return this.operationHandle != null;
+ }
+
+ public void setOperationHandleIsSet(boolean value) {
+ if (!value) {
+ this.operationHandle = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case STATUS:
+ if (value == null) {
+ unsetStatus();
+ } else {
+ setStatus((TStatus)value);
+ }
+ break;
+
+ case OPERATION_HANDLE:
+ if (value == null) {
+ unsetOperationHandle();
+ } else {
+ setOperationHandle((TOperationHandle)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case STATUS:
+ return getStatus();
+
+ case OPERATION_HANDLE:
+ return getOperationHandle();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case STATUS:
+ return isSetStatus();
+ case OPERATION_HANDLE:
+ return isSetOperationHandle();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TDownloadDataResp)
+ return this.equals((TDownloadDataResp)that);
+ return false;
+ }
+
+ public boolean equals(TDownloadDataResp that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_status = true && this.isSetStatus();
+ boolean that_present_status = true && that.isSetStatus();
+ if (this_present_status || that_present_status) {
+ if (!(this_present_status && that_present_status))
+ return false;
+ if (!this.status.equals(that.status))
+ return false;
+ }
+
+ boolean this_present_operationHandle = true && this.isSetOperationHandle();
+ boolean that_present_operationHandle = true && that.isSetOperationHandle();
+ if (this_present_operationHandle || that_present_operationHandle) {
+ if (!(this_present_operationHandle && that_present_operationHandle))
+ return false;
+ if (!this.operationHandle.equals(that.operationHandle))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetStatus()) ? 131071 : 524287);
+ if (isSetStatus())
+ hashCode = hashCode * 8191 + status.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetOperationHandle()) ? 131071 : 524287);
+ if (isSetOperationHandle())
+ hashCode = hashCode * 8191 + operationHandle.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TDownloadDataResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStatus(), other.isSetStatus());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStatus()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, other.status);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetOperationHandle(), other.isSetOperationHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOperationHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.operationHandle, other.operationHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TDownloadDataResp(");
+ boolean first = true;
+
+ sb.append("status:");
+ if (this.status == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.status);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("operationHandle:");
+ if (this.operationHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.operationHandle);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetStatus()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'status' is unset! Struct:" + toString());
+ }
+
+ if (!isSetOperationHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'operationHandle' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (status != null) {
+ status.validate();
+ }
+ if (operationHandle != null) {
+ operationHandle.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TDownloadDataRespStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDownloadDataRespStandardScheme getScheme() {
+ return new TDownloadDataRespStandardScheme();
+ }
+ }
+
+ private static class TDownloadDataRespStandardScheme extends org.apache.thrift.scheme.StandardScheme<TDownloadDataResp> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TDownloadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // STATUS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // OPERATION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TDownloadDataResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.status != null) {
+ oprot.writeFieldBegin(STATUS_FIELD_DESC);
+ struct.status.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.operationHandle != null) {
+ oprot.writeFieldBegin(OPERATION_HANDLE_FIELD_DESC);
+ struct.operationHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TDownloadDataRespTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TDownloadDataRespTupleScheme getScheme() {
+ return new TDownloadDataRespTupleScheme();
+ }
+ }
+
+ private static class TDownloadDataRespTupleScheme extends org.apache.thrift.scheme.TupleScheme<TDownloadDataResp> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TDownloadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.status.write(oprot);
+ struct.operationHandle.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TDownloadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
index 361c950..926e270 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
@@ -687,13 +687,13 @@ package org.apache.hive.service.rpc.thrift;
case 5: // TABLE_TYPES
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
- org.apache.thrift.protocol.TList _list182 = iprot.readListBegin();
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list182.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem183;
- for (int _i184 = 0; _i184 < _list182.size; ++_i184)
+ org.apache.thrift.protocol.TList _list192 = iprot.readListBegin();
+ struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list192.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem193;
+ for (int _i194 = 0; _i194 < _list192.size; ++_i194)
{
- _elem183 = iprot.readString();
- struct.tableTypes.add(_elem183);
+ _elem193 = iprot.readString();
+ struct.tableTypes.add(_elem193);
}
iprot.readListEnd();
}
@@ -746,9 +746,9 @@ package org.apache.hive.service.rpc.thrift;
oprot.writeFieldBegin(TABLE_TYPES_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tableTypes.size()));
- for (java.lang.String _iter185 : struct.tableTypes)
+ for (java.lang.String _iter195 : struct.tableTypes)
{
- oprot.writeString(_iter185);
+ oprot.writeString(_iter195);
}
oprot.writeListEnd();
}
@@ -799,9 +799,9 @@ package org.apache.hive.service.rpc.thrift;
if (struct.isSetTableTypes()) {
{
oprot.writeI32(struct.tableTypes.size());
- for (java.lang.String _iter186 : struct.tableTypes)
+ for (java.lang.String _iter196 : struct.tableTypes)
{
- oprot.writeString(_iter186);
+ oprot.writeString(_iter196);
}
}
}
@@ -828,13 +828,13 @@ package org.apache.hive.service.rpc.thrift;
}
if (incoming.get(3)) {
{
- org.apache.thrift.protocol.TList _list187 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list187.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem188;
- for (int _i189 = 0; _i189 < _list187.size; ++_i189)
+ org.apache.thrift.protocol.TList _list197 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list197.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem198;
+ for (int _i199 = 0; _i199 < _list197.size; ++_i199)
{
- _elem188 = iprot.readString();
- struct.tableTypes.add(_elem188);
+ _elem198 = iprot.readString();
+ struct.tableTypes.add(_elem198);
}
}
struct.setTableTypesIsSet(true);
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TProgressUpdateResp.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TProgressUpdateResp.java
index c371c18..09742ec 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TProgressUpdateResp.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TProgressUpdateResp.java
@@ -776,13 +776,13 @@ package org.apache.hive.service.rpc.thrift;
case 1: // HEADER_NAMES
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
- org.apache.thrift.protocol.TList _list190 = iprot.readListBegin();
- struct.headerNames = new java.util.ArrayList<java.lang.String>(_list190.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem191;
- for (int _i192 = 0; _i192 < _list190.size; ++_i192)
+ org.apache.thrift.protocol.TList _list200 = iprot.readListBegin();
+ struct.headerNames = new java.util.ArrayList<java.lang.String>(_list200.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem201;
+ for (int _i202 = 0; _i202 < _list200.size; ++_i202)
{
- _elem191 = iprot.readString();
- struct.headerNames.add(_elem191);
+ _elem201 = iprot.readString();
+ struct.headerNames.add(_elem201);
}
iprot.readListEnd();
}
@@ -794,23 +794,23 @@ package org.apache.hive.service.rpc.thrift;
case 2: // ROWS
if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
{
- org.apache.thrift.protocol.TList _list193 = iprot.readListBegin();
- struct.rows = new java.util.ArrayList<java.util.List<java.lang.String>>(_list193.size);
- @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> _elem194;
- for (int _i195 = 0; _i195 < _list193.size; ++_i195)
+ org.apache.thrift.protocol.TList _list203 = iprot.readListBegin();
+ struct.rows = new java.util.ArrayList<java.util.List<java.lang.String>>(_list203.size);
+ @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> _elem204;
+ for (int _i205 = 0; _i205 < _list203.size; ++_i205)
{
{
- org.apache.thrift.protocol.TList _list196 = iprot.readListBegin();
- _elem194 = new java.util.ArrayList<java.lang.String>(_list196.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem197;
- for (int _i198 = 0; _i198 < _list196.size; ++_i198)
+ org.apache.thrift.protocol.TList _list206 = iprot.readListBegin();
+ _elem204 = new java.util.ArrayList<java.lang.String>(_list206.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem207;
+ for (int _i208 = 0; _i208 < _list206.size; ++_i208)
{
- _elem197 = iprot.readString();
- _elem194.add(_elem197);
+ _elem207 = iprot.readString();
+ _elem204.add(_elem207);
}
iprot.readListEnd();
}
- struct.rows.add(_elem194);
+ struct.rows.add(_elem204);
}
iprot.readListEnd();
}
@@ -868,9 +868,9 @@ package org.apache.hive.service.rpc.thrift;
oprot.writeFieldBegin(HEADER_NAMES_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.headerNames.size()));
- for (java.lang.String _iter199 : struct.headerNames)
+ for (java.lang.String _iter209 : struct.headerNames)
{
- oprot.writeString(_iter199);
+ oprot.writeString(_iter209);
}
oprot.writeListEnd();
}
@@ -880,13 +880,13 @@ package org.apache.hive.service.rpc.thrift;
oprot.writeFieldBegin(ROWS_FIELD_DESC);
{
oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.LIST, struct.rows.size()));
- for (java.util.List<java.lang.String> _iter200 : struct.rows)
+ for (java.util.List<java.lang.String> _iter210 : struct.rows)
{
{
- oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter200.size()));
- for (java.lang.String _iter201 : _iter200)
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter210.size()));
+ for (java.lang.String _iter211 : _iter210)
{
- oprot.writeString(_iter201);
+ oprot.writeString(_iter211);
}
oprot.writeListEnd();
}
@@ -930,20 +930,20 @@ package org.apache.hive.service.rpc.thrift;
org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
{
oprot.writeI32(struct.headerNames.size());
- for (java.lang.String _iter202 : struct.headerNames)
+ for (java.lang.String _iter212 : struct.headerNames)
{
- oprot.writeString(_iter202);
+ oprot.writeString(_iter212);
}
}
{
oprot.writeI32(struct.rows.size());
- for (java.util.List<java.lang.String> _iter203 : struct.rows)
+ for (java.util.List<java.lang.String> _iter213 : struct.rows)
{
{
- oprot.writeI32(_iter203.size());
- for (java.lang.String _iter204 : _iter203)
+ oprot.writeI32(_iter213.size());
+ for (java.lang.String _iter214 : _iter213)
{
- oprot.writeString(_iter204);
+ oprot.writeString(_iter214);
}
}
}
@@ -958,33 +958,33 @@ package org.apache.hive.service.rpc.thrift;
public void read(org.apache.thrift.protocol.TProtocol prot, TProgressUpdateResp struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
{
- org.apache.thrift.protocol.TList _list205 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
- struct.headerNames = new java.util.ArrayList<java.lang.String>(_list205.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem206;
- for (int _i207 = 0; _i207 < _list205.size; ++_i207)
+ org.apache.thrift.protocol.TList _list215 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ struct.headerNames = new java.util.ArrayList<java.lang.String>(_list215.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem216;
+ for (int _i217 = 0; _i217 < _list215.size; ++_i217)
{
- _elem206 = iprot.readString();
- struct.headerNames.add(_elem206);
+ _elem216 = iprot.readString();
+ struct.headerNames.add(_elem216);
}
}
struct.setHeaderNamesIsSet(true);
{
- org.apache.thrift.protocol.TList _list208 = iprot.readListBegin(org.apache.thrift.protocol.TType.LIST);
- struct.rows = new java.util.ArrayList<java.util.List<java.lang.String>>(_list208.size);
- @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> _elem209;
- for (int _i210 = 0; _i210 < _list208.size; ++_i210)
+ org.apache.thrift.protocol.TList _list218 = iprot.readListBegin(org.apache.thrift.protocol.TType.LIST);
+ struct.rows = new java.util.ArrayList<java.util.List<java.lang.String>>(_list218.size);
+ @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> _elem219;
+ for (int _i220 = 0; _i220 < _list218.size; ++_i220)
{
{
- org.apache.thrift.protocol.TList _list211 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
- _elem209 = new java.util.ArrayList<java.lang.String>(_list211.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem212;
- for (int _i213 = 0; _i213 < _list211.size; ++_i213)
+ org.apache.thrift.protocol.TList _list221 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
+ _elem219 = new java.util.ArrayList<java.lang.String>(_list221.size);
+ @org.apache.thrift.annotation.Nullable java.lang.String _elem222;
+ for (int _i223 = 0; _i223 < _list221.size; ++_i223)
{
- _elem212 = iprot.readString();
- _elem209.add(_elem212);
+ _elem222 = iprot.readString();
+ _elem219.add(_elem222);
}
}
- struct.rows.add(_elem209);
+ struct.rows.add(_elem219);
}
}
struct.setRowsIsSet(true);
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataReq.java
similarity index 53%
copy from service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
copy to service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataReq.java
index 361c950..f2487e4 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetTablesReq.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataReq.java
@@ -8,31 +8,28 @@ package org.apache.hive.service.rpc.thrift;
@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)")
-@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TGetTablesReq implements org.apache.thrift.TBase<TGetTablesReq, TGetTablesReq._Fields>, java.io.Serializable, Cloneable, Comparable<TGetTablesReq> {
- private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGetTablesReq");
+@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TUploadDataReq implements org.apache.thrift.TBase<TUploadDataReq, TUploadDataReq._Fields>, java.io.Serializable, Cloneable, Comparable<TUploadDataReq> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TUploadDataReq");
private static final org.apache.thrift.protocol.TField SESSION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("sessionHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
- private static final org.apache.thrift.protocol.TField CATALOG_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("catalogName", org.apache.thrift.protocol.TType.STRING, (short)2);
- private static final org.apache.thrift.protocol.TField SCHEMA_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("schemaName", org.apache.thrift.protocol.TType.STRING, (short)3);
- private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)4);
- private static final org.apache.thrift.protocol.TField TABLE_TYPES_FIELD_DESC = new org.apache.thrift.protocol.TField("tableTypes", org.apache.thrift.protocol.TType.LIST, (short)5);
+ private static final org.apache.thrift.protocol.TField TABLE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tableName", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField PATH_FIELD_DESC = new org.apache.thrift.protocol.TField("path", org.apache.thrift.protocol.TType.STRING, (short)3);
+ private static final org.apache.thrift.protocol.TField VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.STRING, (short)4);
- private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TGetTablesReqStandardSchemeFactory();
- private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TGetTablesReqTupleSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TUploadDataReqStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TUploadDataReqTupleSchemeFactory();
private @org.apache.thrift.annotation.Nullable TSessionHandle sessionHandle; // required
- private @org.apache.thrift.annotation.Nullable java.lang.String catalogName; // optional
- private @org.apache.thrift.annotation.Nullable java.lang.String schemaName; // optional
private @org.apache.thrift.annotation.Nullable java.lang.String tableName; // optional
- private @org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> tableTypes; // optional
+ private @org.apache.thrift.annotation.Nullable java.lang.String path; // optional
+ private @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer values; // required
/** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
public enum _Fields implements org.apache.thrift.TFieldIdEnum {
SESSION_HANDLE((short)1, "sessionHandle"),
- CATALOG_NAME((short)2, "catalogName"),
- SCHEMA_NAME((short)3, "schemaName"),
- TABLE_NAME((short)4, "tableName"),
- TABLE_TYPES((short)5, "tableTypes");
+ TABLE_NAME((short)2, "tableName"),
+ PATH((short)3, "path"),
+ VALUES((short)4, "values");
private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
@@ -50,14 +47,12 @@ package org.apache.hive.service.rpc.thrift;
switch(fieldId) {
case 1: // SESSION_HANDLE
return SESSION_HANDLE;
- case 2: // CATALOG_NAME
- return CATALOG_NAME;
- case 3: // SCHEMA_NAME
- return SCHEMA_NAME;
- case 4: // TABLE_NAME
+ case 2: // TABLE_NAME
return TABLE_NAME;
- case 5: // TABLE_TYPES
- return TABLE_TYPES;
+ case 3: // PATH
+ return PATH;
+ case 4: // VALUES
+ return VALUES;
default:
return null;
}
@@ -99,68 +94,62 @@ package org.apache.hive.service.rpc.thrift;
}
// isset id assignments
- private static final _Fields optionals[] = {_Fields.CATALOG_NAME,_Fields.SCHEMA_NAME,_Fields.TABLE_NAME,_Fields.TABLE_TYPES};
+ private static final _Fields optionals[] = {_Fields.TABLE_NAME,_Fields.PATH};
public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
static {
java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
tmpMap.put(_Fields.SESSION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("sessionHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TSessionHandle.class)));
- tmpMap.put(_Fields.CATALOG_NAME, new org.apache.thrift.meta_data.FieldMetaData("catalogName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
- tmpMap.put(_Fields.SCHEMA_NAME, new org.apache.thrift.meta_data.FieldMetaData("schemaName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
tmpMap.put(_Fields.TABLE_NAME, new org.apache.thrift.meta_data.FieldMetaData("tableName", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "TPatternOrIdentifier")));
- tmpMap.put(_Fields.TABLE_TYPES, new org.apache.thrift.meta_data.FieldMetaData("tableTypes", org.apache.thrift.TFieldRequirementType.OPTIONAL,
- new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
- new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.PATH, new org.apache.thrift.meta_data.FieldMetaData("path", org.apache.thrift.TFieldRequirementType.OPTIONAL,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)));
metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
- org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetTablesReq.class, metaDataMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TUploadDataReq.class, metaDataMap);
}
- public TGetTablesReq() {
+ public TUploadDataReq() {
}
- public TGetTablesReq(
- TSessionHandle sessionHandle)
+ public TUploadDataReq(
+ TSessionHandle sessionHandle,
+ java.nio.ByteBuffer values)
{
this();
this.sessionHandle = sessionHandle;
+ this.values = org.apache.thrift.TBaseHelper.copyBinary(values);
}
/**
* Performs a deep copy on <i>other</i>.
*/
- public TGetTablesReq(TGetTablesReq other) {
+ public TUploadDataReq(TUploadDataReq other) {
if (other.isSetSessionHandle()) {
this.sessionHandle = new TSessionHandle(other.sessionHandle);
}
- if (other.isSetCatalogName()) {
- this.catalogName = other.catalogName;
- }
- if (other.isSetSchemaName()) {
- this.schemaName = other.schemaName;
- }
if (other.isSetTableName()) {
this.tableName = other.tableName;
}
- if (other.isSetTableTypes()) {
- java.util.List<java.lang.String> __this__tableTypes = new java.util.ArrayList<java.lang.String>(other.tableTypes);
- this.tableTypes = __this__tableTypes;
+ if (other.isSetPath()) {
+ this.path = other.path;
+ }
+ if (other.isSetValues()) {
+ this.values = org.apache.thrift.TBaseHelper.copyBinary(other.values);
}
}
- public TGetTablesReq deepCopy() {
- return new TGetTablesReq(this);
+ public TUploadDataReq deepCopy() {
+ return new TUploadDataReq(this);
}
@Override
public void clear() {
this.sessionHandle = null;
- this.catalogName = null;
- this.schemaName = null;
this.tableName = null;
- this.tableTypes = null;
+ this.path = null;
+ this.values = null;
}
@org.apache.thrift.annotation.Nullable
@@ -188,54 +177,6 @@ package org.apache.hive.service.rpc.thrift;
}
@org.apache.thrift.annotation.Nullable
- public java.lang.String getCatalogName() {
- return this.catalogName;
- }
-
- public void setCatalogName(@org.apache.thrift.annotation.Nullable java.lang.String catalogName) {
- this.catalogName = catalogName;
- }
-
- public void unsetCatalogName() {
- this.catalogName = null;
- }
-
- /** Returns true if field catalogName is set (has been assigned a value) and false otherwise */
- public boolean isSetCatalogName() {
- return this.catalogName != null;
- }
-
- public void setCatalogNameIsSet(boolean value) {
- if (!value) {
- this.catalogName = null;
- }
- }
-
- @org.apache.thrift.annotation.Nullable
- public java.lang.String getSchemaName() {
- return this.schemaName;
- }
-
- public void setSchemaName(@org.apache.thrift.annotation.Nullable java.lang.String schemaName) {
- this.schemaName = schemaName;
- }
-
- public void unsetSchemaName() {
- this.schemaName = null;
- }
-
- /** Returns true if field schemaName is set (has been assigned a value) and false otherwise */
- public boolean isSetSchemaName() {
- return this.schemaName != null;
- }
-
- public void setSchemaNameIsSet(boolean value) {
- if (!value) {
- this.schemaName = null;
- }
- }
-
- @org.apache.thrift.annotation.Nullable
public java.lang.String getTableName() {
return this.tableName;
}
@@ -259,43 +200,59 @@ package org.apache.hive.service.rpc.thrift;
}
}
- public int getTableTypesSize() {
- return (this.tableTypes == null) ? 0 : this.tableTypes.size();
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.String getPath() {
+ return this.path;
}
- @org.apache.thrift.annotation.Nullable
- public java.util.Iterator<java.lang.String> getTableTypesIterator() {
- return (this.tableTypes == null) ? null : this.tableTypes.iterator();
+ public void setPath(@org.apache.thrift.annotation.Nullable java.lang.String path) {
+ this.path = path;
+ }
+
+ public void unsetPath() {
+ this.path = null;
}
- public void addToTableTypes(java.lang.String elem) {
- if (this.tableTypes == null) {
- this.tableTypes = new java.util.ArrayList<java.lang.String>();
+ /** Returns true if field path is set (has been assigned a value) and false otherwise */
+ public boolean isSetPath() {
+ return this.path != null;
+ }
+
+ public void setPathIsSet(boolean value) {
+ if (!value) {
+ this.path = null;
}
- this.tableTypes.add(elem);
}
- @org.apache.thrift.annotation.Nullable
- public java.util.List<java.lang.String> getTableTypes() {
- return this.tableTypes;
+ public byte[] getValues() {
+ setValues(org.apache.thrift.TBaseHelper.rightSize(values));
+ return values == null ? null : values.array();
}
- public void setTableTypes(@org.apache.thrift.annotation.Nullable java.util.List<java.lang.String> tableTypes) {
- this.tableTypes = tableTypes;
+ public java.nio.ByteBuffer bufferForValues() {
+ return org.apache.thrift.TBaseHelper.copyBinary(values);
}
- public void unsetTableTypes() {
- this.tableTypes = null;
+ public void setValues(byte[] values) {
+ this.values = values == null ? (java.nio.ByteBuffer)null : java.nio.ByteBuffer.wrap(values.clone());
}
- /** Returns true if field tableTypes is set (has been assigned a value) and false otherwise */
- public boolean isSetTableTypes() {
- return this.tableTypes != null;
+ public void setValues(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer values) {
+ this.values = org.apache.thrift.TBaseHelper.copyBinary(values);
}
- public void setTableTypesIsSet(boolean value) {
+ public void unsetValues() {
+ this.values = null;
+ }
+
+ /** Returns true if field values is set (has been assigned a value) and false otherwise */
+ public boolean isSetValues() {
+ return this.values != null;
+ }
+
+ public void setValuesIsSet(boolean value) {
if (!value) {
- this.tableTypes = null;
+ this.values = null;
}
}
@@ -309,35 +266,31 @@ package org.apache.hive.service.rpc.thrift;
}
break;
- case CATALOG_NAME:
+ case TABLE_NAME:
if (value == null) {
- unsetCatalogName();
+ unsetTableName();
} else {
- setCatalogName((java.lang.String)value);
+ setTableName((java.lang.String)value);
}
break;
- case SCHEMA_NAME:
+ case PATH:
if (value == null) {
- unsetSchemaName();
+ unsetPath();
} else {
- setSchemaName((java.lang.String)value);
+ setPath((java.lang.String)value);
}
break;
- case TABLE_NAME:
+ case VALUES:
if (value == null) {
- unsetTableName();
+ unsetValues();
} else {
- setTableName((java.lang.String)value);
- }
- break;
-
- case TABLE_TYPES:
- if (value == null) {
- unsetTableTypes();
- } else {
- setTableTypes((java.util.List<java.lang.String>)value);
+ if (value instanceof byte[]) {
+ setValues((byte[])value);
+ } else {
+ setValues((java.nio.ByteBuffer)value);
+ }
}
break;
@@ -350,17 +303,14 @@ package org.apache.hive.service.rpc.thrift;
case SESSION_HANDLE:
return getSessionHandle();
- case CATALOG_NAME:
- return getCatalogName();
-
- case SCHEMA_NAME:
- return getSchemaName();
-
case TABLE_NAME:
return getTableName();
- case TABLE_TYPES:
- return getTableTypes();
+ case PATH:
+ return getPath();
+
+ case VALUES:
+ return getValues();
}
throw new java.lang.IllegalStateException();
@@ -375,26 +325,24 @@ package org.apache.hive.service.rpc.thrift;
switch (field) {
case SESSION_HANDLE:
return isSetSessionHandle();
- case CATALOG_NAME:
- return isSetCatalogName();
- case SCHEMA_NAME:
- return isSetSchemaName();
case TABLE_NAME:
return isSetTableName();
- case TABLE_TYPES:
- return isSetTableTypes();
+ case PATH:
+ return isSetPath();
+ case VALUES:
+ return isSetValues();
}
throw new java.lang.IllegalStateException();
}
@Override
public boolean equals(java.lang.Object that) {
- if (that instanceof TGetTablesReq)
- return this.equals((TGetTablesReq)that);
+ if (that instanceof TUploadDataReq)
+ return this.equals((TUploadDataReq)that);
return false;
}
- public boolean equals(TGetTablesReq that) {
+ public boolean equals(TUploadDataReq that) {
if (that == null)
return false;
if (this == that)
@@ -409,24 +357,6 @@ package org.apache.hive.service.rpc.thrift;
return false;
}
- boolean this_present_catalogName = true && this.isSetCatalogName();
- boolean that_present_catalogName = true && that.isSetCatalogName();
- if (this_present_catalogName || that_present_catalogName) {
- if (!(this_present_catalogName && that_present_catalogName))
- return false;
- if (!this.catalogName.equals(that.catalogName))
- return false;
- }
-
- boolean this_present_schemaName = true && this.isSetSchemaName();
- boolean that_present_schemaName = true && that.isSetSchemaName();
- if (this_present_schemaName || that_present_schemaName) {
- if (!(this_present_schemaName && that_present_schemaName))
- return false;
- if (!this.schemaName.equals(that.schemaName))
- return false;
- }
-
boolean this_present_tableName = true && this.isSetTableName();
boolean that_present_tableName = true && that.isSetTableName();
if (this_present_tableName || that_present_tableName) {
@@ -436,12 +366,21 @@ package org.apache.hive.service.rpc.thrift;
return false;
}
- boolean this_present_tableTypes = true && this.isSetTableTypes();
- boolean that_present_tableTypes = true && that.isSetTableTypes();
- if (this_present_tableTypes || that_present_tableTypes) {
- if (!(this_present_tableTypes && that_present_tableTypes))
+ boolean this_present_path = true && this.isSetPath();
+ boolean that_present_path = true && that.isSetPath();
+ if (this_present_path || that_present_path) {
+ if (!(this_present_path && that_present_path))
return false;
- if (!this.tableTypes.equals(that.tableTypes))
+ if (!this.path.equals(that.path))
+ return false;
+ }
+
+ boolean this_present_values = true && this.isSetValues();
+ boolean that_present_values = true && that.isSetValues();
+ if (this_present_values || that_present_values) {
+ if (!(this_present_values && that_present_values))
+ return false;
+ if (!this.values.equals(that.values))
return false;
}
@@ -456,27 +395,23 @@ package org.apache.hive.service.rpc.thrift;
if (isSetSessionHandle())
hashCode = hashCode * 8191 + sessionHandle.hashCode();
- hashCode = hashCode * 8191 + ((isSetCatalogName()) ? 131071 : 524287);
- if (isSetCatalogName())
- hashCode = hashCode * 8191 + catalogName.hashCode();
-
- hashCode = hashCode * 8191 + ((isSetSchemaName()) ? 131071 : 524287);
- if (isSetSchemaName())
- hashCode = hashCode * 8191 + schemaName.hashCode();
-
hashCode = hashCode * 8191 + ((isSetTableName()) ? 131071 : 524287);
if (isSetTableName())
hashCode = hashCode * 8191 + tableName.hashCode();
- hashCode = hashCode * 8191 + ((isSetTableTypes()) ? 131071 : 524287);
- if (isSetTableTypes())
- hashCode = hashCode * 8191 + tableTypes.hashCode();
+ hashCode = hashCode * 8191 + ((isSetPath()) ? 131071 : 524287);
+ if (isSetPath())
+ hashCode = hashCode * 8191 + path.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetValues()) ? 131071 : 524287);
+ if (isSetValues())
+ hashCode = hashCode * 8191 + values.hashCode();
return hashCode;
}
@Override
- public int compareTo(TGetTablesReq other) {
+ public int compareTo(TUploadDataReq other) {
if (!getClass().equals(other.getClass())) {
return getClass().getName().compareTo(other.getClass().getName());
}
@@ -493,42 +428,32 @@ package org.apache.hive.service.rpc.thrift;
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetCatalogName(), other.isSetCatalogName());
+ lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetCatalogName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.catalogName, other.catalogName);
+ if (isSetTableName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
if (lastComparison != 0) {
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetSchemaName(), other.isSetSchemaName());
+ lastComparison = java.lang.Boolean.compare(isSetPath(), other.isSetPath());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetSchemaName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.schemaName, other.schemaName);
+ if (isSetPath()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.path, other.path);
if (lastComparison != 0) {
return lastComparison;
}
}
- lastComparison = java.lang.Boolean.compare(isSetTableName(), other.isSetTableName());
+ lastComparison = java.lang.Boolean.compare(isSetValues(), other.isSetValues());
if (lastComparison != 0) {
return lastComparison;
}
- if (isSetTableName()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableName, other.tableName);
- if (lastComparison != 0) {
- return lastComparison;
- }
- }
- lastComparison = java.lang.Boolean.compare(isSetTableTypes(), other.isSetTableTypes());
- if (lastComparison != 0) {
- return lastComparison;
- }
- if (isSetTableTypes()) {
- lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tableTypes, other.tableTypes);
+ if (isSetValues()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, other.values);
if (lastComparison != 0) {
return lastComparison;
}
@@ -551,7 +476,7 @@ package org.apache.hive.service.rpc.thrift;
@Override
public java.lang.String toString() {
- java.lang.StringBuilder sb = new java.lang.StringBuilder("TGetTablesReq(");
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TUploadDataReq(");
boolean first = true;
sb.append("sessionHandle:");
@@ -561,26 +486,6 @@ package org.apache.hive.service.rpc.thrift;
sb.append(this.sessionHandle);
}
first = false;
- if (isSetCatalogName()) {
- if (!first) sb.append(", ");
- sb.append("catalogName:");
- if (this.catalogName == null) {
- sb.append("null");
- } else {
- sb.append(this.catalogName);
- }
- first = false;
- }
- if (isSetSchemaName()) {
- if (!first) sb.append(", ");
- sb.append("schemaName:");
- if (this.schemaName == null) {
- sb.append("null");
- } else {
- sb.append(this.schemaName);
- }
- first = false;
- }
if (isSetTableName()) {
if (!first) sb.append(", ");
sb.append("tableName:");
@@ -591,16 +496,24 @@ package org.apache.hive.service.rpc.thrift;
}
first = false;
}
- if (isSetTableTypes()) {
+ if (isSetPath()) {
if (!first) sb.append(", ");
- sb.append("tableTypes:");
- if (this.tableTypes == null) {
+ sb.append("path:");
+ if (this.path == null) {
sb.append("null");
} else {
- sb.append(this.tableTypes);
+ sb.append(this.path);
}
first = false;
}
+ if (!first) sb.append(", ");
+ sb.append("values:");
+ if (this.values == null) {
+ sb.append("null");
+ } else {
+ org.apache.thrift.TBaseHelper.toString(this.values, sb);
+ }
+ first = false;
sb.append(")");
return sb.toString();
}
@@ -611,6 +524,10 @@ package org.apache.hive.service.rpc.thrift;
throw new org.apache.thrift.protocol.TProtocolException("Required field 'sessionHandle' is unset! Struct:" + toString());
}
+ if (!isSetValues()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'values' is unset! Struct:" + toString());
+ }
+
// check for sub-struct validity
if (sessionHandle != null) {
sessionHandle.validate();
@@ -633,15 +550,15 @@ package org.apache.hive.service.rpc.thrift;
}
}
- private static class TGetTablesReqStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
- public TGetTablesReqStandardScheme getScheme() {
- return new TGetTablesReqStandardScheme();
+ private static class TUploadDataReqStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TUploadDataReqStandardScheme getScheme() {
+ return new TUploadDataReqStandardScheme();
}
}
- private static class TGetTablesReqStandardScheme extends org.apache.thrift.scheme.StandardScheme<TGetTablesReq> {
+ private static class TUploadDataReqStandardScheme extends org.apache.thrift.scheme.StandardScheme<TUploadDataReq> {
- public void read(org.apache.thrift.protocol.TProtocol iprot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TUploadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TField schemeField;
iprot.readStructBegin();
while (true)
@@ -660,44 +577,26 @@ package org.apache.hive.service.rpc.thrift;
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 2: // CATALOG_NAME
+ case 2: // TABLE_NAME
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.catalogName = iprot.readString();
- struct.setCatalogNameIsSet(true);
+ struct.tableName = iprot.readString();
+ struct.setTableNameIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 3: // SCHEMA_NAME
+ case 3: // PATH
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.schemaName = iprot.readString();
- struct.setSchemaNameIsSet(true);
+ struct.path = iprot.readString();
+ struct.setPathIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
break;
- case 4: // TABLE_NAME
+ case 4: // VALUES
if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
- struct.tableName = iprot.readString();
- struct.setTableNameIsSet(true);
- } else {
- org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
- }
- break;
- case 5: // TABLE_TYPES
- if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
- {
- org.apache.thrift.protocol.TList _list182 = iprot.readListBegin();
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list182.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem183;
- for (int _i184 = 0; _i184 < _list182.size; ++_i184)
- {
- _elem183 = iprot.readString();
- struct.tableTypes.add(_elem183);
- }
- iprot.readListEnd();
- }
- struct.setTableTypesIsSet(true);
+ struct.values = iprot.readBinary();
+ struct.setValuesIsSet(true);
} else {
org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
}
@@ -711,7 +610,7 @@ package org.apache.hive.service.rpc.thrift;
struct.validate();
}
- public void write(org.apache.thrift.protocol.TProtocol oprot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TUploadDataReq struct) throws org.apache.thrift.TException {
struct.validate();
oprot.writeStructBegin(STRUCT_DESC);
@@ -720,20 +619,6 @@ package org.apache.hive.service.rpc.thrift;
struct.sessionHandle.write(oprot);
oprot.writeFieldEnd();
}
- if (struct.catalogName != null) {
- if (struct.isSetCatalogName()) {
- oprot.writeFieldBegin(CATALOG_NAME_FIELD_DESC);
- oprot.writeString(struct.catalogName);
- oprot.writeFieldEnd();
- }
- }
- if (struct.schemaName != null) {
- if (struct.isSetSchemaName()) {
- oprot.writeFieldBegin(SCHEMA_NAME_FIELD_DESC);
- oprot.writeString(struct.schemaName);
- oprot.writeFieldEnd();
- }
- }
if (struct.tableName != null) {
if (struct.isSetTableName()) {
oprot.writeFieldBegin(TABLE_NAME_FIELD_DESC);
@@ -741,103 +626,69 @@ package org.apache.hive.service.rpc.thrift;
oprot.writeFieldEnd();
}
}
- if (struct.tableTypes != null) {
- if (struct.isSetTableTypes()) {
- oprot.writeFieldBegin(TABLE_TYPES_FIELD_DESC);
- {
- oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tableTypes.size()));
- for (java.lang.String _iter185 : struct.tableTypes)
- {
- oprot.writeString(_iter185);
- }
- oprot.writeListEnd();
- }
+ if (struct.path != null) {
+ if (struct.isSetPath()) {
+ oprot.writeFieldBegin(PATH_FIELD_DESC);
+ oprot.writeString(struct.path);
oprot.writeFieldEnd();
}
}
+ if (struct.values != null) {
+ oprot.writeFieldBegin(VALUES_FIELD_DESC);
+ oprot.writeBinary(struct.values);
+ oprot.writeFieldEnd();
+ }
oprot.writeFieldStop();
oprot.writeStructEnd();
}
}
- private static class TGetTablesReqTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
- public TGetTablesReqTupleScheme getScheme() {
- return new TGetTablesReqTupleScheme();
+ private static class TUploadDataReqTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TUploadDataReqTupleScheme getScheme() {
+ return new TUploadDataReqTupleScheme();
}
}
- private static class TGetTablesReqTupleScheme extends org.apache.thrift.scheme.TupleScheme<TGetTablesReq> {
+ private static class TUploadDataReqTupleScheme extends org.apache.thrift.scheme.TupleScheme<TUploadDataReq> {
@Override
- public void write(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void write(org.apache.thrift.protocol.TProtocol prot, TUploadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
struct.sessionHandle.write(oprot);
+ oprot.writeBinary(struct.values);
java.util.BitSet optionals = new java.util.BitSet();
- if (struct.isSetCatalogName()) {
+ if (struct.isSetTableName()) {
optionals.set(0);
}
- if (struct.isSetSchemaName()) {
+ if (struct.isSetPath()) {
optionals.set(1);
}
- if (struct.isSetTableName()) {
- optionals.set(2);
- }
- if (struct.isSetTableTypes()) {
- optionals.set(3);
- }
- oprot.writeBitSet(optionals, 4);
- if (struct.isSetCatalogName()) {
- oprot.writeString(struct.catalogName);
- }
- if (struct.isSetSchemaName()) {
- oprot.writeString(struct.schemaName);
- }
+ oprot.writeBitSet(optionals, 2);
if (struct.isSetTableName()) {
oprot.writeString(struct.tableName);
}
- if (struct.isSetTableTypes()) {
- {
- oprot.writeI32(struct.tableTypes.size());
- for (java.lang.String _iter186 : struct.tableTypes)
- {
- oprot.writeString(_iter186);
- }
- }
+ if (struct.isSetPath()) {
+ oprot.writeString(struct.path);
}
}
@Override
- public void read(org.apache.thrift.protocol.TProtocol prot, TGetTablesReq struct) throws org.apache.thrift.TException {
+ public void read(org.apache.thrift.protocol.TProtocol prot, TUploadDataReq struct) throws org.apache.thrift.TException {
org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
struct.sessionHandle = new TSessionHandle();
struct.sessionHandle.read(iprot);
struct.setSessionHandleIsSet(true);
- java.util.BitSet incoming = iprot.readBitSet(4);
+ struct.values = iprot.readBinary();
+ struct.setValuesIsSet(true);
+ java.util.BitSet incoming = iprot.readBitSet(2);
if (incoming.get(0)) {
- struct.catalogName = iprot.readString();
- struct.setCatalogNameIsSet(true);
- }
- if (incoming.get(1)) {
- struct.schemaName = iprot.readString();
- struct.setSchemaNameIsSet(true);
- }
- if (incoming.get(2)) {
struct.tableName = iprot.readString();
struct.setTableNameIsSet(true);
}
- if (incoming.get(3)) {
- {
- org.apache.thrift.protocol.TList _list187 = iprot.readListBegin(org.apache.thrift.protocol.TType.STRING);
- struct.tableTypes = new java.util.ArrayList<java.lang.String>(_list187.size);
- @org.apache.thrift.annotation.Nullable java.lang.String _elem188;
- for (int _i189 = 0; _i189 < _list187.size; ++_i189)
- {
- _elem188 = iprot.readString();
- struct.tableTypes.add(_elem188);
- }
- }
- struct.setTableTypesIsSet(true);
+ if (incoming.get(1)) {
+ struct.path = iprot.readString();
+ struct.setPathIsSet(true);
}
}
}
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataResp.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataResp.java
new file mode 100644
index 0000000..84c5488
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TUploadDataResp.java
@@ -0,0 +1,477 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.rpc.thrift;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)")
+@org.apache.hadoop.hive.common.classification.InterfaceAudience.Public @org.apache.hadoop.hive.common.classification.InterfaceStability.Stable public class TUploadDataResp implements org.apache.thrift.TBase<TUploadDataResp, TUploadDataResp._Fields>, java.io.Serializable, Cloneable, Comparable<TUploadDataResp> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TUploadDataResp");
+
+ private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+ private static final org.apache.thrift.protocol.TField OPERATION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("operationHandle", org.apache.thrift.protocol.TType.STRUCT, (short)2);
+
+ private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TUploadDataRespStandardSchemeFactory();
+ private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TUploadDataRespTupleSchemeFactory();
+
+ private @org.apache.thrift.annotation.Nullable TStatus status; // required
+ private @org.apache.thrift.annotation.Nullable TOperationHandle operationHandle; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ STATUS((short)1, "status"),
+ OPERATION_HANDLE((short)2, "operationHandle");
+
+ private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+ static {
+ for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // STATUS
+ return STATUS;
+ case 2: // OPERATION_HANDLE
+ return OPERATION_HANDLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ @org.apache.thrift.annotation.Nullable
+ public static _Fields findByName(java.lang.String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final java.lang.String _fieldName;
+
+ _Fields(short thriftId, java.lang.String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public java.lang.String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TStatus.class)));
+ tmpMap.put(_Fields.OPERATION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("operationHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TOperationHandle.class)));
+ metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TUploadDataResp.class, metaDataMap);
+ }
+
+ public TUploadDataResp() {
+ }
+
+ public TUploadDataResp(
+ TStatus status,
+ TOperationHandle operationHandle)
+ {
+ this();
+ this.status = status;
+ this.operationHandle = operationHandle;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TUploadDataResp(TUploadDataResp other) {
+ if (other.isSetStatus()) {
+ this.status = new TStatus(other.status);
+ }
+ if (other.isSetOperationHandle()) {
+ this.operationHandle = new TOperationHandle(other.operationHandle);
+ }
+ }
+
+ public TUploadDataResp deepCopy() {
+ return new TUploadDataResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.status = null;
+ this.operationHandle = null;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TStatus getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(@org.apache.thrift.annotation.Nullable TStatus status) {
+ this.status = status;
+ }
+
+ public void unsetStatus() {
+ this.status = null;
+ }
+
+ /** Returns true if field status is set (has been assigned a value) and false otherwise */
+ public boolean isSetStatus() {
+ return this.status != null;
+ }
+
+ public void setStatusIsSet(boolean value) {
+ if (!value) {
+ this.status = null;
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public TOperationHandle getOperationHandle() {
+ return this.operationHandle;
+ }
+
+ public void setOperationHandle(@org.apache.thrift.annotation.Nullable TOperationHandle operationHandle) {
+ this.operationHandle = operationHandle;
+ }
+
+ public void unsetOperationHandle() {
+ this.operationHandle = null;
+ }
+
+ /** Returns true if field operationHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetOperationHandle() {
+ return this.operationHandle != null;
+ }
+
+ public void setOperationHandleIsSet(boolean value) {
+ if (!value) {
+ this.operationHandle = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
+ switch (field) {
+ case STATUS:
+ if (value == null) {
+ unsetStatus();
+ } else {
+ setStatus((TStatus)value);
+ }
+ break;
+
+ case OPERATION_HANDLE:
+ if (value == null) {
+ unsetOperationHandle();
+ } else {
+ setOperationHandle((TOperationHandle)value);
+ }
+ break;
+
+ }
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public java.lang.Object getFieldValue(_Fields field) {
+ switch (field) {
+ case STATUS:
+ return getStatus();
+
+ case OPERATION_HANDLE:
+ return getOperationHandle();
+
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new java.lang.IllegalArgumentException();
+ }
+
+ switch (field) {
+ case STATUS:
+ return isSetStatus();
+ case OPERATION_HANDLE:
+ return isSetOperationHandle();
+ }
+ throw new java.lang.IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(java.lang.Object that) {
+ if (that instanceof TUploadDataResp)
+ return this.equals((TUploadDataResp)that);
+ return false;
+ }
+
+ public boolean equals(TUploadDataResp that) {
+ if (that == null)
+ return false;
+ if (this == that)
+ return true;
+
+ boolean this_present_status = true && this.isSetStatus();
+ boolean that_present_status = true && that.isSetStatus();
+ if (this_present_status || that_present_status) {
+ if (!(this_present_status && that_present_status))
+ return false;
+ if (!this.status.equals(that.status))
+ return false;
+ }
+
+ boolean this_present_operationHandle = true && this.isSetOperationHandle();
+ boolean that_present_operationHandle = true && that.isSetOperationHandle();
+ if (this_present_operationHandle || that_present_operationHandle) {
+ if (!(this_present_operationHandle && that_present_operationHandle))
+ return false;
+ if (!this.operationHandle.equals(that.operationHandle))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hashCode = 1;
+
+ hashCode = hashCode * 8191 + ((isSetStatus()) ? 131071 : 524287);
+ if (isSetStatus())
+ hashCode = hashCode * 8191 + status.hashCode();
+
+ hashCode = hashCode * 8191 + ((isSetOperationHandle()) ? 131071 : 524287);
+ if (isSetOperationHandle())
+ hashCode = hashCode * 8191 + operationHandle.hashCode();
+
+ return hashCode;
+ }
+
+ @Override
+ public int compareTo(TUploadDataResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = java.lang.Boolean.compare(isSetStatus(), other.isSetStatus());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetStatus()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, other.status);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = java.lang.Boolean.compare(isSetOperationHandle(), other.isSetOperationHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOperationHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.operationHandle, other.operationHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ @org.apache.thrift.annotation.Nullable
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ scheme(iprot).read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ scheme(oprot).write(oprot, this);
+ }
+
+ @Override
+ public java.lang.String toString() {
+ java.lang.StringBuilder sb = new java.lang.StringBuilder("TUploadDataResp(");
+ boolean first = true;
+
+ sb.append("status:");
+ if (this.status == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.status);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("operationHandle:");
+ if (this.operationHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.operationHandle);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetStatus()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'status' is unset! Struct:" + toString());
+ }
+
+ if (!isSetOperationHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'operationHandle' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (status != null) {
+ status.validate();
+ }
+ if (operationHandle != null) {
+ operationHandle.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TUploadDataRespStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TUploadDataRespStandardScheme getScheme() {
+ return new TUploadDataRespStandardScheme();
+ }
+ }
+
+ private static class TUploadDataRespStandardScheme extends org.apache.thrift.scheme.StandardScheme<TUploadDataResp> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TUploadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // STATUS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // OPERATION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TUploadDataResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.status != null) {
+ oprot.writeFieldBegin(STATUS_FIELD_DESC);
+ struct.status.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ if (struct.operationHandle != null) {
+ oprot.writeFieldBegin(OPERATION_HANDLE_FIELD_DESC);
+ struct.operationHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TUploadDataRespTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+ public TUploadDataRespTupleScheme getScheme() {
+ return new TUploadDataRespTupleScheme();
+ }
+ }
+
+ private static class TUploadDataRespTupleScheme extends org.apache.thrift.scheme.TupleScheme<TUploadDataResp> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TUploadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.status.write(oprot);
+ struct.operationHandle.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TUploadDataResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+ struct.status = new TStatus();
+ struct.status.read(iprot);
+ struct.setStatusIsSet(true);
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ }
+ }
+
+ private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+ return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+ }
+}
+
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIServiceClient.php b/service-rpc/src/gen/thrift/gen-php/TCLIServiceClient.php
index b265b49..2c0eacc 100644
--- a/service-rpc/src/gen/thrift/gen-php/TCLIServiceClient.php
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIServiceClient.php
@@ -1384,4 +1384,122 @@ class TCLIServiceClient implements \TCLIServiceIf
}
throw new \Exception("SetClientInfo failed: unknown result");
}
+
+ public function UploadData(\TUploadDataReq $req)
+ {
+ $this->send_UploadData($req);
+ return $this->recv_UploadData();
+ }
+
+ public function send_UploadData(\TUploadDataReq $req)
+ {
+ $args = new \TCLIService_UploadData_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel) {
+ thrift_protocol_write_binary(
+ $this->output_,
+ 'UploadData',
+ TMessageType::CALL,
+ $args,
+ $this->seqid_,
+ $this->output_->isStrictWrite()
+ );
+ } else {
+ $this->output_->writeMessageBegin('UploadData', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_UploadData()
+ {
+ $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) {
+ $result = thrift_protocol_read_binary(
+ $this->input_,
+ '\TCLIService_UploadData_result',
+ $this->input_->isStrictRead()
+ );
+ } else {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_UploadData_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("UploadData failed: unknown result");
+ }
+
+ public function DownloadData(\TDownloadDataReq $req)
+ {
+ $this->send_DownloadData($req);
+ return $this->recv_DownloadData();
+ }
+
+ public function send_DownloadData(\TDownloadDataReq $req)
+ {
+ $args = new \TCLIService_DownloadData_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel) {
+ thrift_protocol_write_binary(
+ $this->output_,
+ 'DownloadData',
+ TMessageType::CALL,
+ $args,
+ $this->seqid_,
+ $this->output_->isStrictWrite()
+ );
+ } else {
+ $this->output_->writeMessageBegin('DownloadData', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_DownloadData()
+ {
+ $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) {
+ $result = thrift_protocol_read_binary(
+ $this->input_,
+ '\TCLIService_DownloadData_result',
+ $this->input_->isStrictRead()
+ );
+ } else {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_DownloadData_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("DownloadData failed: unknown result");
+ }
}
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIServiceIf.php b/service-rpc/src/gen/thrift/gen-php/TCLIServiceIf.php
index 3309bcb..8008361 100644
--- a/service-rpc/src/gen/thrift/gen-php/TCLIServiceIf.php
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIServiceIf.php
@@ -131,4 +131,14 @@ interface TCLIServiceIf
* @return \TSetClientInfoResp
*/
public function SetClientInfo(\TSetClientInfoReq $req);
+ /**
+ * @param \TUploadDataReq $req
+ * @return \TUploadDataResp
+ */
+ public function UploadData(\TUploadDataReq $req);
+ /**
+ * @param \TDownloadDataReq $req
+ * @return \TDownloadDataResp
+ */
+ public function DownloadData(\TDownloadDataReq $req);
}
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_args.php b/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_args.php
new file mode 100644
index 0000000..b61cf17
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_args.php
@@ -0,0 +1,97 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TCLIService_DownloadData_args
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'isRequired' => false,
+ 'type' => TType::STRUCT,
+ 'class' => '\TDownloadDataReq',
+ ),
+ );
+
+ /**
+ * @var \TDownloadDataReq
+ */
+ public $req = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TCLIService_DownloadData_args';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TDownloadDataReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_DownloadData_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_result.php b/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_result.php
new file mode 100644
index 0000000..4af9c5a
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIService_DownloadData_result.php
@@ -0,0 +1,97 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TCLIService_DownloadData_result
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'isRequired' => false,
+ 'type' => TType::STRUCT,
+ 'class' => '\TDownloadDataResp',
+ ),
+ );
+
+ /**
+ * @var \TDownloadDataResp
+ */
+ public $success = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TCLIService_DownloadData_result';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TDownloadDataResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_DownloadData_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_args.php b/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_args.php
new file mode 100644
index 0000000..c1da61f
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_args.php
@@ -0,0 +1,97 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TCLIService_UploadData_args
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'isRequired' => false,
+ 'type' => TType::STRUCT,
+ 'class' => '\TUploadDataReq',
+ ),
+ );
+
+ /**
+ * @var \TUploadDataReq
+ */
+ public $req = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TCLIService_UploadData_args';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TUploadDataReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_UploadData_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_result.php b/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_result.php
new file mode 100644
index 0000000..e22a132
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIService_UploadData_result.php
@@ -0,0 +1,97 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TCLIService_UploadData_result
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'isRequired' => false,
+ 'type' => TType::STRUCT,
+ 'class' => '\TUploadDataResp',
+ ),
+ );
+
+ /**
+ * @var \TUploadDataResp
+ */
+ public $success = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TCLIService_UploadData_result';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TUploadDataResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_UploadData_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php b/service-rpc/src/gen/thrift/gen-php/TDownloadDataReq.php
similarity index 66%
copy from service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
copy to service-rpc/src/gen/thrift/gen-php/TDownloadDataReq.php
index 38100e7..91edfe8 100644
--- a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
+++ b/service-rpc/src/gen/thrift/gen-php/TDownloadDataReq.php
@@ -14,7 +14,7 @@ use Thrift\Protocol\TProtocol;
use Thrift\Protocol\TBinaryProtocolAccelerated;
use Thrift\Exception\TApplicationException;
-class TGetTablesReq
+class TDownloadDataReq
{
static public $isValidate = false;
@@ -26,26 +26,30 @@ class TGetTablesReq
'class' => '\TSessionHandle',
),
2 => array(
- 'var' => 'catalogName',
+ 'var' => 'tableName',
'isRequired' => false,
'type' => TType::STRING,
),
3 => array(
- 'var' => 'schemaName',
+ 'var' => 'query',
'isRequired' => false,
'type' => TType::STRING,
),
4 => array(
- 'var' => 'tableName',
+ 'var' => 'format',
'isRequired' => false,
'type' => TType::STRING,
),
5 => array(
- 'var' => 'tableTypes',
+ 'var' => 'downloadOptions',
'isRequired' => false,
- 'type' => TType::LST,
- 'etype' => TType::STRING,
- 'elem' => array(
+ 'type' => TType::MAP,
+ 'ktype' => TType::STRING,
+ 'vtype' => TType::STRING,
+ 'key' => array(
+ 'type' => TType::STRING,
+ ),
+ 'val' => array(
'type' => TType::STRING,
),
),
@@ -58,19 +62,19 @@ class TGetTablesReq
/**
* @var string
*/
- public $catalogName = null;
+ public $tableName = null;
/**
* @var string
*/
- public $schemaName = null;
+ public $query = null;
/**
* @var string
*/
- public $tableName = null;
+ public $format = null;
/**
- * @var string[]
+ * @var array
*/
- public $tableTypes = null;
+ public $downloadOptions = null;
public function __construct($vals = null)
{
@@ -78,24 +82,24 @@ class TGetTablesReq
if (isset($vals['sessionHandle'])) {
$this->sessionHandle = $vals['sessionHandle'];
}
- if (isset($vals['catalogName'])) {
- $this->catalogName = $vals['catalogName'];
- }
- if (isset($vals['schemaName'])) {
- $this->schemaName = $vals['schemaName'];
- }
if (isset($vals['tableName'])) {
$this->tableName = $vals['tableName'];
}
- if (isset($vals['tableTypes'])) {
- $this->tableTypes = $vals['tableTypes'];
+ if (isset($vals['query'])) {
+ $this->query = $vals['query'];
+ }
+ if (isset($vals['format'])) {
+ $this->format = $vals['format'];
+ }
+ if (isset($vals['downloadOptions'])) {
+ $this->downloadOptions = $vals['downloadOptions'];
}
}
}
public function getName()
{
- return 'TGetTablesReq';
+ return 'TDownloadDataReq';
}
@@ -122,37 +126,40 @@ class TGetTablesReq
break;
case 2:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->catalogName);
+ $xfer += $input->readString($this->tableName);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->schemaName);
+ $xfer += $input->readString($this->query);
} else {
$xfer += $input->skip($ftype);
}
break;
case 4:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->tableName);
+ $xfer += $input->readString($this->format);
} else {
$xfer += $input->skip($ftype);
}
break;
case 5:
- if ($ftype == TType::LST) {
- $this->tableTypes = array();
+ if ($ftype == TType::MAP) {
+ $this->downloadOptions = array();
$_size161 = 0;
- $_etype164 = 0;
- $xfer += $input->readListBegin($_etype164, $_size161);
+ $_ktype162 = 0;
+ $_vtype163 = 0;
+ $xfer += $input->readMapBegin($_ktype162, $_vtype163, $_size161);
for ($_i165 = 0; $_i165 < $_size161; ++$_i165) {
- $elem166 = null;
- $xfer += $input->readString($elem166);
- $this->tableTypes []= $elem166;
+ $key166 = '';
+ $val167 = '';
+ $xfer += $input->readString($key166);
+ $xfer += $input->readString($val167);
+ $this->downloadOptions[$key166] = $val167;
}
- $xfer += $input->readListEnd();
+ $xfer += $input->readMapEnd();
} else {
$xfer += $input->skip($ftype);
}
@@ -170,7 +177,7 @@ class TGetTablesReq
public function write($output)
{
$xfer = 0;
- $xfer += $output->writeStructBegin('TGetTablesReq');
+ $xfer += $output->writeStructBegin('TDownloadDataReq');
if ($this->sessionHandle !== null) {
if (!is_object($this->sessionHandle)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -179,31 +186,32 @@ class TGetTablesReq
$xfer += $this->sessionHandle->write($output);
$xfer += $output->writeFieldEnd();
}
- if ($this->catalogName !== null) {
- $xfer += $output->writeFieldBegin('catalogName', TType::STRING, 2);
- $xfer += $output->writeString($this->catalogName);
+ if ($this->tableName !== null) {
+ $xfer += $output->writeFieldBegin('tableName', TType::STRING, 2);
+ $xfer += $output->writeString($this->tableName);
$xfer += $output->writeFieldEnd();
}
- if ($this->schemaName !== null) {
- $xfer += $output->writeFieldBegin('schemaName', TType::STRING, 3);
- $xfer += $output->writeString($this->schemaName);
+ if ($this->query !== null) {
+ $xfer += $output->writeFieldBegin('query', TType::STRING, 3);
+ $xfer += $output->writeString($this->query);
$xfer += $output->writeFieldEnd();
}
- if ($this->tableName !== null) {
- $xfer += $output->writeFieldBegin('tableName', TType::STRING, 4);
- $xfer += $output->writeString($this->tableName);
+ if ($this->format !== null) {
+ $xfer += $output->writeFieldBegin('format', TType::STRING, 4);
+ $xfer += $output->writeString($this->format);
$xfer += $output->writeFieldEnd();
}
- if ($this->tableTypes !== null) {
- if (!is_array($this->tableTypes)) {
+ if ($this->downloadOptions !== null) {
+ if (!is_array($this->downloadOptions)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
- $xfer += $output->writeFieldBegin('tableTypes', TType::LST, 5);
- $output->writeListBegin(TType::STRING, count($this->tableTypes));
- foreach ($this->tableTypes as $iter167) {
- $xfer += $output->writeString($iter167);
+ $xfer += $output->writeFieldBegin('downloadOptions', TType::MAP, 5);
+ $output->writeMapBegin(TType::STRING, TType::STRING, count($this->downloadOptions));
+ foreach ($this->downloadOptions as $kiter168 => $viter169) {
+ $xfer += $output->writeString($kiter168);
+ $xfer += $output->writeString($viter169);
}
- $output->writeListEnd();
+ $output->writeMapEnd();
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
diff --git a/service-rpc/src/gen/thrift/gen-php/TDownloadDataResp.php b/service-rpc/src/gen/thrift/gen-php/TDownloadDataResp.php
new file mode 100644
index 0000000..2878a89
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TDownloadDataResp.php
@@ -0,0 +1,126 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TDownloadDataResp
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 1 => array(
+ 'var' => 'status',
+ 'isRequired' => true,
+ 'type' => TType::STRUCT,
+ 'class' => '\TStatus',
+ ),
+ 2 => array(
+ 'var' => 'operationHandle',
+ 'isRequired' => true,
+ 'type' => TType::STRUCT,
+ 'class' => '\TOperationHandle',
+ ),
+ );
+
+ /**
+ * @var \TStatus
+ */
+ public $status = null;
+ /**
+ * @var \TOperationHandle
+ */
+ public $operationHandle = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['status'])) {
+ $this->status = $vals['status'];
+ }
+ if (isset($vals['operationHandle'])) {
+ $this->operationHandle = $vals['operationHandle'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TDownloadDataResp';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->status = new \TStatus();
+ $xfer += $this->status->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->operationHandle = new \TOperationHandle();
+ $xfer += $this->operationHandle->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TDownloadDataResp');
+ if ($this->status !== null) {
+ if (!is_object($this->status)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('status', TType::STRUCT, 1);
+ $xfer += $this->status->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->operationHandle !== null) {
+ if (!is_object($this->operationHandle)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('operationHandle', TType::STRUCT, 2);
+ $xfer += $this->operationHandle->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php b/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
index 38100e7..89fb1b9 100644
--- a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
+++ b/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
@@ -144,13 +144,13 @@ class TGetTablesReq
case 5:
if ($ftype == TType::LST) {
$this->tableTypes = array();
- $_size161 = 0;
- $_etype164 = 0;
- $xfer += $input->readListBegin($_etype164, $_size161);
- for ($_i165 = 0; $_i165 < $_size161; ++$_i165) {
- $elem166 = null;
- $xfer += $input->readString($elem166);
- $this->tableTypes []= $elem166;
+ $_size170 = 0;
+ $_etype173 = 0;
+ $xfer += $input->readListBegin($_etype173, $_size170);
+ for ($_i174 = 0; $_i174 < $_size170; ++$_i174) {
+ $elem175 = null;
+ $xfer += $input->readString($elem175);
+ $this->tableTypes []= $elem175;
}
$xfer += $input->readListEnd();
} else {
@@ -200,8 +200,8 @@ class TGetTablesReq
}
$xfer += $output->writeFieldBegin('tableTypes', TType::LST, 5);
$output->writeListBegin(TType::STRING, count($this->tableTypes));
- foreach ($this->tableTypes as $iter167) {
- $xfer += $output->writeString($iter167);
+ foreach ($this->tableTypes as $iter176) {
+ $xfer += $output->writeString($iter176);
}
$output->writeListEnd();
$xfer += $output->writeFieldEnd();
diff --git a/service-rpc/src/gen/thrift/gen-php/TProgressUpdateResp.php b/service-rpc/src/gen/thrift/gen-php/TProgressUpdateResp.php
index 31a4ce3..92a40db 100644
--- a/service-rpc/src/gen/thrift/gen-php/TProgressUpdateResp.php
+++ b/service-rpc/src/gen/thrift/gen-php/TProgressUpdateResp.php
@@ -135,13 +135,13 @@ class TProgressUpdateResp
case 1:
if ($ftype == TType::LST) {
$this->headerNames = array();
- $_size168 = 0;
- $_etype171 = 0;
- $xfer += $input->readListBegin($_etype171, $_size168);
- for ($_i172 = 0; $_i172 < $_size168; ++$_i172) {
- $elem173 = null;
- $xfer += $input->readString($elem173);
- $this->headerNames []= $elem173;
+ $_size177 = 0;
+ $_etype180 = 0;
+ $xfer += $input->readListBegin($_etype180, $_size177);
+ for ($_i181 = 0; $_i181 < $_size177; ++$_i181) {
+ $elem182 = null;
+ $xfer += $input->readString($elem182);
+ $this->headerNames []= $elem182;
}
$xfer += $input->readListEnd();
} else {
@@ -151,22 +151,22 @@ class TProgressUpdateResp
case 2:
if ($ftype == TType::LST) {
$this->rows = array();
- $_size174 = 0;
- $_etype177 = 0;
- $xfer += $input->readListBegin($_etype177, $_size174);
- for ($_i178 = 0; $_i178 < $_size174; ++$_i178) {
- $elem179 = null;
- $elem179 = array();
- $_size180 = 0;
- $_etype183 = 0;
- $xfer += $input->readListBegin($_etype183, $_size180);
- for ($_i184 = 0; $_i184 < $_size180; ++$_i184) {
- $elem185 = null;
- $xfer += $input->readString($elem185);
- $elem179 []= $elem185;
+ $_size183 = 0;
+ $_etype186 = 0;
+ $xfer += $input->readListBegin($_etype186, $_size183);
+ for ($_i187 = 0; $_i187 < $_size183; ++$_i187) {
+ $elem188 = null;
+ $elem188 = array();
+ $_size189 = 0;
+ $_etype192 = 0;
+ $xfer += $input->readListBegin($_etype192, $_size189);
+ for ($_i193 = 0; $_i193 < $_size189; ++$_i193) {
+ $elem194 = null;
+ $xfer += $input->readString($elem194);
+ $elem188 []= $elem194;
}
$xfer += $input->readListEnd();
- $this->rows []= $elem179;
+ $this->rows []= $elem188;
}
$xfer += $input->readListEnd();
} else {
@@ -221,8 +221,8 @@ class TProgressUpdateResp
}
$xfer += $output->writeFieldBegin('headerNames', TType::LST, 1);
$output->writeListBegin(TType::STRING, count($this->headerNames));
- foreach ($this->headerNames as $iter186) {
- $xfer += $output->writeString($iter186);
+ foreach ($this->headerNames as $iter195) {
+ $xfer += $output->writeString($iter195);
}
$output->writeListEnd();
$xfer += $output->writeFieldEnd();
@@ -233,10 +233,10 @@ class TProgressUpdateResp
}
$xfer += $output->writeFieldBegin('rows', TType::LST, 2);
$output->writeListBegin(TType::LST, count($this->rows));
- foreach ($this->rows as $iter187) {
- $output->writeListBegin(TType::STRING, count($iter187));
- foreach ($iter187 as $iter188) {
- $xfer += $output->writeString($iter188);
+ foreach ($this->rows as $iter196) {
+ $output->writeListBegin(TType::STRING, count($iter196));
+ foreach ($iter196 as $iter197) {
+ $xfer += $output->writeString($iter197);
}
$output->writeListEnd();
}
diff --git a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php b/service-rpc/src/gen/thrift/gen-php/TUploadDataReq.php
similarity index 60%
copy from service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
copy to service-rpc/src/gen/thrift/gen-php/TUploadDataReq.php
index 38100e7..dda8b34 100644
--- a/service-rpc/src/gen/thrift/gen-php/TGetTablesReq.php
+++ b/service-rpc/src/gen/thrift/gen-php/TUploadDataReq.php
@@ -14,7 +14,7 @@ use Thrift\Protocol\TProtocol;
use Thrift\Protocol\TBinaryProtocolAccelerated;
use Thrift\Exception\TApplicationException;
-class TGetTablesReq
+class TUploadDataReq
{
static public $isValidate = false;
@@ -26,29 +26,20 @@ class TGetTablesReq
'class' => '\TSessionHandle',
),
2 => array(
- 'var' => 'catalogName',
+ 'var' => 'tableName',
'isRequired' => false,
'type' => TType::STRING,
),
3 => array(
- 'var' => 'schemaName',
+ 'var' => 'path',
'isRequired' => false,
'type' => TType::STRING,
),
4 => array(
- 'var' => 'tableName',
- 'isRequired' => false,
+ 'var' => 'values',
+ 'isRequired' => true,
'type' => TType::STRING,
),
- 5 => array(
- 'var' => 'tableTypes',
- 'isRequired' => false,
- 'type' => TType::LST,
- 'etype' => TType::STRING,
- 'elem' => array(
- 'type' => TType::STRING,
- ),
- ),
);
/**
@@ -58,19 +49,15 @@ class TGetTablesReq
/**
* @var string
*/
- public $catalogName = null;
+ public $tableName = null;
/**
* @var string
*/
- public $schemaName = null;
+ public $path = null;
/**
* @var string
*/
- public $tableName = null;
- /**
- * @var string[]
- */
- public $tableTypes = null;
+ public $values = null;
public function __construct($vals = null)
{
@@ -78,24 +65,21 @@ class TGetTablesReq
if (isset($vals['sessionHandle'])) {
$this->sessionHandle = $vals['sessionHandle'];
}
- if (isset($vals['catalogName'])) {
- $this->catalogName = $vals['catalogName'];
- }
- if (isset($vals['schemaName'])) {
- $this->schemaName = $vals['schemaName'];
- }
if (isset($vals['tableName'])) {
$this->tableName = $vals['tableName'];
}
- if (isset($vals['tableTypes'])) {
- $this->tableTypes = $vals['tableTypes'];
+ if (isset($vals['path'])) {
+ $this->path = $vals['path'];
+ }
+ if (isset($vals['values'])) {
+ $this->values = $vals['values'];
}
}
}
public function getName()
{
- return 'TGetTablesReq';
+ return 'TUploadDataReq';
}
@@ -122,37 +106,21 @@ class TGetTablesReq
break;
case 2:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->catalogName);
+ $xfer += $input->readString($this->tableName);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->schemaName);
+ $xfer += $input->readString($this->path);
} else {
$xfer += $input->skip($ftype);
}
break;
case 4:
if ($ftype == TType::STRING) {
- $xfer += $input->readString($this->tableName);
- } else {
- $xfer += $input->skip($ftype);
- }
- break;
- case 5:
- if ($ftype == TType::LST) {
- $this->tableTypes = array();
- $_size161 = 0;
- $_etype164 = 0;
- $xfer += $input->readListBegin($_etype164, $_size161);
- for ($_i165 = 0; $_i165 < $_size161; ++$_i165) {
- $elem166 = null;
- $xfer += $input->readString($elem166);
- $this->tableTypes []= $elem166;
- }
- $xfer += $input->readListEnd();
+ $xfer += $input->readString($this->values);
} else {
$xfer += $input->skip($ftype);
}
@@ -170,7 +138,7 @@ class TGetTablesReq
public function write($output)
{
$xfer = 0;
- $xfer += $output->writeStructBegin('TGetTablesReq');
+ $xfer += $output->writeStructBegin('TUploadDataReq');
if ($this->sessionHandle !== null) {
if (!is_object($this->sessionHandle)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
@@ -179,31 +147,19 @@ class TGetTablesReq
$xfer += $this->sessionHandle->write($output);
$xfer += $output->writeFieldEnd();
}
- if ($this->catalogName !== null) {
- $xfer += $output->writeFieldBegin('catalogName', TType::STRING, 2);
- $xfer += $output->writeString($this->catalogName);
- $xfer += $output->writeFieldEnd();
- }
- if ($this->schemaName !== null) {
- $xfer += $output->writeFieldBegin('schemaName', TType::STRING, 3);
- $xfer += $output->writeString($this->schemaName);
- $xfer += $output->writeFieldEnd();
- }
if ($this->tableName !== null) {
- $xfer += $output->writeFieldBegin('tableName', TType::STRING, 4);
+ $xfer += $output->writeFieldBegin('tableName', TType::STRING, 2);
$xfer += $output->writeString($this->tableName);
$xfer += $output->writeFieldEnd();
}
- if ($this->tableTypes !== null) {
- if (!is_array($this->tableTypes)) {
- throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
- }
- $xfer += $output->writeFieldBegin('tableTypes', TType::LST, 5);
- $output->writeListBegin(TType::STRING, count($this->tableTypes));
- foreach ($this->tableTypes as $iter167) {
- $xfer += $output->writeString($iter167);
- }
- $output->writeListEnd();
+ if ($this->path !== null) {
+ $xfer += $output->writeFieldBegin('path', TType::STRING, 3);
+ $xfer += $output->writeString($this->path);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->values !== null) {
+ $xfer += $output->writeFieldBegin('values', TType::STRING, 4);
+ $xfer += $output->writeString($this->values);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
diff --git a/service-rpc/src/gen/thrift/gen-php/TUploadDataResp.php b/service-rpc/src/gen/thrift/gen-php/TUploadDataResp.php
new file mode 100644
index 0000000..b6cc02f
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-php/TUploadDataResp.php
@@ -0,0 +1,126 @@
+<?php
+/**
+ * Autogenerated by Thrift Compiler (0.14.1)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+use Thrift\Base\TBase;
+use Thrift\Type\TType;
+use Thrift\Type\TMessageType;
+use Thrift\Exception\TException;
+use Thrift\Exception\TProtocolException;
+use Thrift\Protocol\TProtocol;
+use Thrift\Protocol\TBinaryProtocolAccelerated;
+use Thrift\Exception\TApplicationException;
+
+class TUploadDataResp
+{
+ static public $isValidate = false;
+
+ static public $_TSPEC = array(
+ 1 => array(
+ 'var' => 'status',
+ 'isRequired' => true,
+ 'type' => TType::STRUCT,
+ 'class' => '\TStatus',
+ ),
+ 2 => array(
+ 'var' => 'operationHandle',
+ 'isRequired' => true,
+ 'type' => TType::STRUCT,
+ 'class' => '\TOperationHandle',
+ ),
+ );
+
+ /**
+ * @var \TStatus
+ */
+ public $status = null;
+ /**
+ * @var \TOperationHandle
+ */
+ public $operationHandle = null;
+
+ public function __construct($vals = null)
+ {
+ if (is_array($vals)) {
+ if (isset($vals['status'])) {
+ $this->status = $vals['status'];
+ }
+ if (isset($vals['operationHandle'])) {
+ $this->operationHandle = $vals['operationHandle'];
+ }
+ }
+ }
+
+ public function getName()
+ {
+ return 'TUploadDataResp';
+ }
+
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true) {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid) {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->status = new \TStatus();
+ $xfer += $this->status->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ case 2:
+ if ($ftype == TType::STRUCT) {
+ $this->operationHandle = new \TOperationHandle();
+ $xfer += $this->operationHandle->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output)
+ {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TUploadDataResp');
+ if ($this->status !== null) {
+ if (!is_object($this->status)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('status', TType::STRUCT, 1);
+ $xfer += $this->status->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ if ($this->operationHandle !== null) {
+ if (!is_object($this->operationHandle)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('operationHandle', TType::STRUCT, 2);
+ $xfer += $this->operationHandle->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+}
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
index 553d39d..bf4f86c 100755
--- a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
+++ b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
@@ -47,6 +47,8 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help':
print(' TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req)')
print(' TGetQueryIdResp GetQueryId(TGetQueryIdReq req)')
print(' TSetClientInfoResp SetClientInfo(TSetClientInfoReq req)')
+ print(' TUploadDataResp UploadData(TUploadDataReq req)')
+ print(' TDownloadDataResp DownloadData(TDownloadDataReq req)')
print('')
sys.exit(0)
@@ -264,6 +266,18 @@ elif cmd == 'SetClientInfo':
sys.exit(1)
pp.pprint(client.SetClientInfo(eval(args[0]),))
+elif cmd == 'UploadData':
+ if len(args) != 1:
+ print('UploadData requires 1 args')
+ sys.exit(1)
+ pp.pprint(client.UploadData(eval(args[0]),))
+
+elif cmd == 'DownloadData':
+ if len(args) != 1:
+ print('DownloadData requires 1 args')
+ sys.exit(1)
+ pp.pprint(client.DownloadData(eval(args[0]),))
+
else:
print('Unrecognized method %s' % cmd)
sys.exit(1)
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
index da53e41..215e484 100644
--- a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
+++ b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
@@ -203,6 +203,22 @@ class Iface(object):
"""
pass
+ def UploadData(self, req):
+ """
+ Parameters:
+ - req
+
+ """
+ pass
+
+ def DownloadData(self, req):
+ """
+ Parameters:
+ - req
+
+ """
+ pass
+
class Client(Iface):
def __init__(self, iprot, oprot=None):
@@ -947,6 +963,70 @@ class Client(Iface):
return result.success
raise TApplicationException(TApplicationException.MISSING_RESULT, "SetClientInfo failed: unknown result")
+ def UploadData(self, req):
+ """
+ Parameters:
+ - req
+
+ """
+ self.send_UploadData(req)
+ return self.recv_UploadData()
+
+ def send_UploadData(self, req):
+ self._oprot.writeMessageBegin('UploadData', TMessageType.CALL, self._seqid)
+ args = UploadData_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_UploadData(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = UploadData_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "UploadData failed: unknown result")
+
+ def DownloadData(self, req):
+ """
+ Parameters:
+ - req
+
+ """
+ self.send_DownloadData(req)
+ return self.recv_DownloadData()
+
+ def send_DownloadData(self, req):
+ self._oprot.writeMessageBegin('DownloadData', TMessageType.CALL, self._seqid)
+ args = DownloadData_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_DownloadData(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = DownloadData_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "DownloadData failed: unknown result")
+
class Processor(Iface, TProcessor):
def __init__(self, handler):
@@ -975,6 +1055,8 @@ class Processor(Iface, TProcessor):
self._processMap["RenewDelegationToken"] = Processor.process_RenewDelegationToken
self._processMap["GetQueryId"] = Processor.process_GetQueryId
self._processMap["SetClientInfo"] = Processor.process_SetClientInfo
+ self._processMap["UploadData"] = Processor.process_UploadData
+ self._processMap["DownloadData"] = Processor.process_DownloadData
self._on_message_begin = None
def on_message_begin(self, func):
@@ -1526,6 +1608,52 @@ class Processor(Iface, TProcessor):
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_UploadData(self, seqid, iprot, oprot):
+ args = UploadData_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = UploadData_result()
+ try:
+ result.success = self._handler.UploadData(args.req)
+ msg_type = TMessageType.REPLY
+ except TTransport.TTransportException:
+ raise
+ except TApplicationException as ex:
+ logging.exception('TApplication exception in handler')
+ msg_type = TMessageType.EXCEPTION
+ result = ex
+ except Exception:
+ logging.exception('Unexpected exception in handler')
+ msg_type = TMessageType.EXCEPTION
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("UploadData", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
+ def process_DownloadData(self, seqid, iprot, oprot):
+ args = DownloadData_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = DownloadData_result()
+ try:
+ result.success = self._handler.DownloadData(args.req)
+ msg_type = TMessageType.REPLY
+ except TTransport.TTransportException:
+ raise
+ except TApplicationException as ex:
+ logging.exception('TApplication exception in handler')
+ msg_type = TMessageType.EXCEPTION
+ result = ex
+ except Exception:
+ logging.exception('Unexpected exception in handler')
+ msg_type = TMessageType.EXCEPTION
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("DownloadData", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
# HELPER FUNCTIONS AND STRUCTURES
@@ -4402,5 +4530,255 @@ all_structs.append(SetClientInfo_result)
SetClientInfo_result.thrift_spec = (
(0, TType.STRUCT, 'success', [TSetClientInfoResp, None], None, ), # 0
)
+
+
+class UploadData_args(object):
+ """
+ Attributes:
+ - req
+
+ """
+
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+ iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TUploadDataReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot._fast_encode is not None and self.thrift_spec is not None:
+ oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+ return
+ oprot.writeStructBegin('UploadData_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.items()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+all_structs.append(UploadData_args)
+UploadData_args.thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', [TUploadDataReq, None], None, ), # 1
+)
+
+
+class UploadData_result(object):
+ """
+ Attributes:
+ - success
+
+ """
+
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+ iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TUploadDataResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot._fast_encode is not None and self.thrift_spec is not None:
+ oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+ return
+ oprot.writeStructBegin('UploadData_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.items()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+all_structs.append(UploadData_result)
+UploadData_result.thrift_spec = (
+ (0, TType.STRUCT, 'success', [TUploadDataResp, None], None, ), # 0
+)
+
+
+class DownloadData_args(object):
+ """
+ Attributes:
+ - req
+
+ """
+
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+ iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TDownloadDataReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot._fast_encode is not None and self.thrift_spec is not None:
+ oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+ return
+ oprot.writeStructBegin('DownloadData_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.items()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+all_structs.append(DownloadData_args)
+DownloadData_args.thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', [TDownloadDataReq, None], None, ), # 1
+)
+
+
+class DownloadData_result(object):
+ """
+ Attributes:
+ - success
+
+ """
+
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+ iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TDownloadDataResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot._fast_encode is not None and self.thrift_spec is not None:
+ oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+ return
+ oprot.writeStructBegin('DownloadData_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.items()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+all_structs.append(DownloadData_result)
+DownloadData_result.thrift_spec = (
+ (0, TType.STRUCT, 'success', [TDownloadDataResp, None], None, ), # 0
+)
fix_spec(all_structs)
del all_structs
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/ttypes.py b/service-rpc/src/gen/thrift/gen-py/TCLIService/ttypes.py
index 4c338e8..bbb3eb5 100644
--- a/service-rpc/src/gen/thrift/gen-py/TCLIService/ttypes.py
+++ b/service-rpc/src/gen/thrift/gen-py/TCLIService/ttypes.py
@@ -4211,6 +4211,363 @@ class TGetTypeInfoResp(object):
return not (self == other)
+class TUploadDataReq(object):
+ """
+ Attributes:
+ - sessionHandle
+ - tableName
+ - path
+ - values
+
+ """
+
+
+ def __init__(self, sessionHandle=None, tableName=None, path=None, values=None,):
+ self.sessionHandle = sessionHandle
+ self.tableName = tableName
+ self.path = path
+ self.values = values
+
+ def read(self, iprot):
+ if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+ iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.sessionHandle = TSessionHandle()
+ self.sessionHandle.read(iprot)
+ else:
+ iprot.skip(ftype)
+ elif fid == 2:
+ if ftype == TType.STRING:
+ self.tableName = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+ else:
+ iprot.skip(ftype)
+ elif fid == 3:
+ if ftype == TType.STRING:
+ self.path = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+ else:
+ iprot.skip(ftype)
+ elif fid == 4:
+ if ftype == TType.STRING:
+ self.values = iprot.readBinary()
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot._fast_encode is not None and self.thrift_spec is not None:
+ oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+ return
+ oprot.writeStructBegin('TUploadDataReq')
+ if self.sessionHandle is not None:
+ oprot.writeFieldBegin('sessionHandle', TType.STRUCT, 1)
+ self.sessionHandle.write(oprot)
+ oprot.writeFieldEnd()
+ if self.tableName is not None:
+ oprot.writeFieldBegin('tableName', TType.STRING, 2)
+ oprot.writeString(self.tableName.encode('utf-8') if sys.version_info[0] == 2 else self.tableName)
+ oprot.writeFieldEnd()
+ if self.path is not None:
+ oprot.writeFieldBegin('path', TType.STRING, 3)
+ oprot.writeString(self.path.encode('utf-8') if sys.version_info[0] == 2 else self.path)
+ oprot.writeFieldEnd()
+ if self.values is not None:
+ oprot.writeFieldBegin('values', TType.STRING, 4)
+ oprot.writeBinary(self.values)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ if self.sessionHandle is None:
+ raise TProtocolException(message='Required field sessionHandle is unset!')
+ if self.values is None:
+ raise TProtocolException(message='Required field values is unset!')
+ return
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.items()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
... 1081 lines suppressed ...