You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by jd...@apache.org on 2016/04/26 19:53:56 UTC
[33/50] [abbrv] hive git commit: HIVE-13130: HS2 changes : API calls
for retrieving primary keys and foreign keys information (Hari Subramaniyan,
reviewed by Ashutosh Chauhan)
http://git-wip-us.apache.org/repos/asf/hive/blob/f13ee089/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
----------------------------------------------------------------------
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 395af2c..66f5e8c 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -7542,6 +7542,604 @@ void TGetFunctionsResp::printTo(std::ostream& out) const {
}
+TGetPrimaryKeysReq::~TGetPrimaryKeysReq() throw() {
+}
+
+
+void TGetPrimaryKeysReq::__set_sessionHandle(const TSessionHandle& val) {
+ this->sessionHandle = val;
+}
+
+void TGetPrimaryKeysReq::__set_catalogName(const TIdentifier& val) {
+ this->catalogName = val;
+__isset.catalogName = true;
+}
+
+void TGetPrimaryKeysReq::__set_schemaName(const TIdentifier& val) {
+ this->schemaName = val;
+__isset.schemaName = true;
+}
+
+void TGetPrimaryKeysReq::__set_tableName(const TIdentifier& val) {
+ this->tableName = val;
+__isset.tableName = true;
+}
+
+uint32_t TGetPrimaryKeysReq::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->catalogName);
+ this->__isset.catalogName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->schemaName);
+ this->__isset.schemaName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ this->__isset.tableName = 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 TGetPrimaryKeysReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetPrimaryKeysReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.catalogName) {
+ xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->catalogName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.schemaName) {
+ xfer += oprot->writeFieldBegin("schemaName", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->schemaName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.tableName) {
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetPrimaryKeysReq &a, TGetPrimaryKeysReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.catalogName, b.catalogName);
+ swap(a.schemaName, b.schemaName);
+ swap(a.tableName, b.tableName);
+ swap(a.__isset, b.__isset);
+}
+
+TGetPrimaryKeysReq::TGetPrimaryKeysReq(const TGetPrimaryKeysReq& other260) {
+ sessionHandle = other260.sessionHandle;
+ catalogName = other260.catalogName;
+ schemaName = other260.schemaName;
+ tableName = other260.tableName;
+ __isset = other260.__isset;
+}
+TGetPrimaryKeysReq& TGetPrimaryKeysReq::operator=(const TGetPrimaryKeysReq& other261) {
+ sessionHandle = other261.sessionHandle;
+ catalogName = other261.catalogName;
+ schemaName = other261.schemaName;
+ tableName = other261.tableName;
+ __isset = other261.__isset;
+ return *this;
+}
+void TGetPrimaryKeysReq::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetPrimaryKeysReq(";
+ out << "sessionHandle=" << to_string(sessionHandle);
+ out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "<null>"));
+ out << ", " << "schemaName="; (__isset.schemaName ? (out << to_string(schemaName)) : (out << "<null>"));
+ out << ", " << "tableName="; (__isset.tableName ? (out << to_string(tableName)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TGetPrimaryKeysResp::~TGetPrimaryKeysResp() throw() {
+}
+
+
+void TGetPrimaryKeysResp::__set_status(const TStatus& val) {
+ this->status = val;
+}
+
+void TGetPrimaryKeysResp::__set_operationHandle(const TOperationHandle& val) {
+ this->operationHandle = val;
+__isset.operationHandle = true;
+}
+
+uint32_t TGetPrimaryKeysResp::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;
+
+ 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);
+ this->__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);
+ return xfer;
+}
+
+uint32_t TGetPrimaryKeysResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetPrimaryKeysResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.operationHandle) {
+ 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(TGetPrimaryKeysResp &a, TGetPrimaryKeysResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.operationHandle, b.operationHandle);
+ swap(a.__isset, b.__isset);
+}
+
+TGetPrimaryKeysResp::TGetPrimaryKeysResp(const TGetPrimaryKeysResp& other262) {
+ status = other262.status;
+ operationHandle = other262.operationHandle;
+ __isset = other262.__isset;
+}
+TGetPrimaryKeysResp& TGetPrimaryKeysResp::operator=(const TGetPrimaryKeysResp& other263) {
+ status = other263.status;
+ operationHandle = other263.operationHandle;
+ __isset = other263.__isset;
+ return *this;
+}
+void TGetPrimaryKeysResp::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetPrimaryKeysResp(";
+ out << "status=" << to_string(status);
+ out << ", " << "operationHandle="; (__isset.operationHandle ? (out << to_string(operationHandle)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TGetCrossReferenceReq::~TGetCrossReferenceReq() throw() {
+}
+
+
+void TGetCrossReferenceReq::__set_sessionHandle(const TSessionHandle& val) {
+ this->sessionHandle = val;
+}
+
+void TGetCrossReferenceReq::__set_parentCatalogName(const TIdentifier& val) {
+ this->parentCatalogName = val;
+__isset.parentCatalogName = true;
+}
+
+void TGetCrossReferenceReq::__set_parentSchemaName(const TIdentifier& val) {
+ this->parentSchemaName = val;
+__isset.parentSchemaName = true;
+}
+
+void TGetCrossReferenceReq::__set_parentTableName(const TIdentifier& val) {
+ this->parentTableName = val;
+__isset.parentTableName = true;
+}
+
+void TGetCrossReferenceReq::__set_foreignCatalogName(const TIdentifier& val) {
+ this->foreignCatalogName = val;
+__isset.foreignCatalogName = true;
+}
+
+void TGetCrossReferenceReq::__set_foreignSchemaName(const TIdentifier& val) {
+ this->foreignSchemaName = val;
+__isset.foreignSchemaName = true;
+}
+
+void TGetCrossReferenceReq::__set_foreignTableName(const TIdentifier& val) {
+ this->foreignTableName = val;
+__isset.foreignTableName = true;
+}
+
+uint32_t TGetCrossReferenceReq::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->parentCatalogName);
+ this->__isset.parentCatalogName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->parentSchemaName);
+ this->__isset.parentSchemaName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->parentTableName);
+ this->__isset.parentTableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->foreignCatalogName);
+ this->__isset.foreignCatalogName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->foreignSchemaName);
+ this->__isset.foreignSchemaName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->foreignTableName);
+ this->__isset.foreignTableName = 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 TGetCrossReferenceReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetCrossReferenceReq");
+
+ xfer += oprot->writeFieldBegin("sessionHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->sessionHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.parentCatalogName) {
+ xfer += oprot->writeFieldBegin("parentCatalogName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->parentCatalogName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.parentSchemaName) {
+ xfer += oprot->writeFieldBegin("parentSchemaName", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->parentSchemaName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.parentTableName) {
+ xfer += oprot->writeFieldBegin("parentTableName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->parentTableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.foreignCatalogName) {
+ xfer += oprot->writeFieldBegin("foreignCatalogName", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->foreignCatalogName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.foreignSchemaName) {
+ xfer += oprot->writeFieldBegin("foreignSchemaName", ::apache::thrift::protocol::T_STRING, 6);
+ xfer += oprot->writeString(this->foreignSchemaName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.foreignTableName) {
+ xfer += oprot->writeFieldBegin("foreignTableName", ::apache::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->foreignTableName);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetCrossReferenceReq &a, TGetCrossReferenceReq &b) {
+ using ::std::swap;
+ swap(a.sessionHandle, b.sessionHandle);
+ swap(a.parentCatalogName, b.parentCatalogName);
+ swap(a.parentSchemaName, b.parentSchemaName);
+ swap(a.parentTableName, b.parentTableName);
+ swap(a.foreignCatalogName, b.foreignCatalogName);
+ swap(a.foreignSchemaName, b.foreignSchemaName);
+ swap(a.foreignTableName, b.foreignTableName);
+ swap(a.__isset, b.__isset);
+}
+
+TGetCrossReferenceReq::TGetCrossReferenceReq(const TGetCrossReferenceReq& other264) {
+ sessionHandle = other264.sessionHandle;
+ parentCatalogName = other264.parentCatalogName;
+ parentSchemaName = other264.parentSchemaName;
+ parentTableName = other264.parentTableName;
+ foreignCatalogName = other264.foreignCatalogName;
+ foreignSchemaName = other264.foreignSchemaName;
+ foreignTableName = other264.foreignTableName;
+ __isset = other264.__isset;
+}
+TGetCrossReferenceReq& TGetCrossReferenceReq::operator=(const TGetCrossReferenceReq& other265) {
+ sessionHandle = other265.sessionHandle;
+ parentCatalogName = other265.parentCatalogName;
+ parentSchemaName = other265.parentSchemaName;
+ parentTableName = other265.parentTableName;
+ foreignCatalogName = other265.foreignCatalogName;
+ foreignSchemaName = other265.foreignSchemaName;
+ foreignTableName = other265.foreignTableName;
+ __isset = other265.__isset;
+ return *this;
+}
+void TGetCrossReferenceReq::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetCrossReferenceReq(";
+ out << "sessionHandle=" << to_string(sessionHandle);
+ out << ", " << "parentCatalogName="; (__isset.parentCatalogName ? (out << to_string(parentCatalogName)) : (out << "<null>"));
+ out << ", " << "parentSchemaName="; (__isset.parentSchemaName ? (out << to_string(parentSchemaName)) : (out << "<null>"));
+ out << ", " << "parentTableName="; (__isset.parentTableName ? (out << to_string(parentTableName)) : (out << "<null>"));
+ out << ", " << "foreignCatalogName="; (__isset.foreignCatalogName ? (out << to_string(foreignCatalogName)) : (out << "<null>"));
+ out << ", " << "foreignSchemaName="; (__isset.foreignSchemaName ? (out << to_string(foreignSchemaName)) : (out << "<null>"));
+ out << ", " << "foreignTableName="; (__isset.foreignTableName ? (out << to_string(foreignTableName)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TGetCrossReferenceResp::~TGetCrossReferenceResp() throw() {
+}
+
+
+void TGetCrossReferenceResp::__set_status(const TStatus& val) {
+ this->status = val;
+}
+
+void TGetCrossReferenceResp::__set_operationHandle(const TOperationHandle& val) {
+ this->operationHandle = val;
+__isset.operationHandle = true;
+}
+
+uint32_t TGetCrossReferenceResp::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;
+
+ 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);
+ this->__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);
+ return xfer;
+}
+
+uint32_t TGetCrossReferenceResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetCrossReferenceResp");
+
+ xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->status.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.operationHandle) {
+ 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(TGetCrossReferenceResp &a, TGetCrossReferenceResp &b) {
+ using ::std::swap;
+ swap(a.status, b.status);
+ swap(a.operationHandle, b.operationHandle);
+ swap(a.__isset, b.__isset);
+}
+
+TGetCrossReferenceResp::TGetCrossReferenceResp(const TGetCrossReferenceResp& other266) {
+ status = other266.status;
+ operationHandle = other266.operationHandle;
+ __isset = other266.__isset;
+}
+TGetCrossReferenceResp& TGetCrossReferenceResp::operator=(const TGetCrossReferenceResp& other267) {
+ status = other267.status;
+ operationHandle = other267.operationHandle;
+ __isset = other267.__isset;
+ return *this;
+}
+void TGetCrossReferenceResp::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetCrossReferenceResp(";
+ out << "status=" << to_string(status);
+ out << ", " << "operationHandle="; (__isset.operationHandle ? (out << to_string(operationHandle)) : (out << "<null>"));
+ out << ")";
+}
+
+
TGetOperationStatusReq::~TGetOperationStatusReq() throw() {
}
@@ -7613,11 +8211,11 @@ void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TGetOperationStatusReq::TGetOperationStatusReq(const TGetOperationStatusReq& other260) {
- operationHandle = other260.operationHandle;
+TGetOperationStatusReq::TGetOperationStatusReq(const TGetOperationStatusReq& other268) {
+ operationHandle = other268.operationHandle;
}
-TGetOperationStatusReq& TGetOperationStatusReq::operator=(const TGetOperationStatusReq& other261) {
- operationHandle = other261.operationHandle;
+TGetOperationStatusReq& TGetOperationStatusReq::operator=(const TGetOperationStatusReq& other269) {
+ operationHandle = other269.operationHandle;
return *this;
}
void TGetOperationStatusReq::printTo(std::ostream& out) const {
@@ -7703,9 +8301,9 @@ uint32_t TGetOperationStatusResp::read(::apache::thrift::protocol::TProtocol* ip
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast262;
- xfer += iprot->readI32(ecast262);
- this->operationState = (TOperationState::type)ecast262;
+ int32_t ecast270;
+ xfer += iprot->readI32(ecast270);
+ this->operationState = (TOperationState::type)ecast270;
this->__isset.operationState = true;
} else {
xfer += iprot->skip(ftype);
@@ -7835,27 +8433,27 @@ void swap(TGetOperationStatusResp &a, TGetOperationStatusResp &b) {
swap(a.__isset, b.__isset);
}
-TGetOperationStatusResp::TGetOperationStatusResp(const TGetOperationStatusResp& other263) {
- status = other263.status;
- operationState = other263.operationState;
- sqlState = other263.sqlState;
- errorCode = other263.errorCode;
- errorMessage = other263.errorMessage;
- taskStatus = other263.taskStatus;
- operationStarted = other263.operationStarted;
- operationCompleted = other263.operationCompleted;
- __isset = other263.__isset;
-}
-TGetOperationStatusResp& TGetOperationStatusResp::operator=(const TGetOperationStatusResp& other264) {
- status = other264.status;
- operationState = other264.operationState;
- sqlState = other264.sqlState;
- errorCode = other264.errorCode;
- errorMessage = other264.errorMessage;
- taskStatus = other264.taskStatus;
- operationStarted = other264.operationStarted;
- operationCompleted = other264.operationCompleted;
- __isset = other264.__isset;
+TGetOperationStatusResp::TGetOperationStatusResp(const TGetOperationStatusResp& other271) {
+ status = other271.status;
+ operationState = other271.operationState;
+ sqlState = other271.sqlState;
+ errorCode = other271.errorCode;
+ errorMessage = other271.errorMessage;
+ taskStatus = other271.taskStatus;
+ operationStarted = other271.operationStarted;
+ operationCompleted = other271.operationCompleted;
+ __isset = other271.__isset;
+}
+TGetOperationStatusResp& TGetOperationStatusResp::operator=(const TGetOperationStatusResp& other272) {
+ status = other272.status;
+ operationState = other272.operationState;
+ sqlState = other272.sqlState;
+ errorCode = other272.errorCode;
+ errorMessage = other272.errorMessage;
+ taskStatus = other272.taskStatus;
+ operationStarted = other272.operationStarted;
+ operationCompleted = other272.operationCompleted;
+ __isset = other272.__isset;
return *this;
}
void TGetOperationStatusResp::printTo(std::ostream& out) const {
@@ -7944,11 +8542,11 @@ void swap(TCancelOperationReq &a, TCancelOperationReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TCancelOperationReq::TCancelOperationReq(const TCancelOperationReq& other265) {
- operationHandle = other265.operationHandle;
+TCancelOperationReq::TCancelOperationReq(const TCancelOperationReq& other273) {
+ operationHandle = other273.operationHandle;
}
-TCancelOperationReq& TCancelOperationReq::operator=(const TCancelOperationReq& other266) {
- operationHandle = other266.operationHandle;
+TCancelOperationReq& TCancelOperationReq::operator=(const TCancelOperationReq& other274) {
+ operationHandle = other274.operationHandle;
return *this;
}
void TCancelOperationReq::printTo(std::ostream& out) const {
@@ -8030,11 +8628,11 @@ void swap(TCancelOperationResp &a, TCancelOperationResp &b) {
swap(a.status, b.status);
}
-TCancelOperationResp::TCancelOperationResp(const TCancelOperationResp& other267) {
- status = other267.status;
+TCancelOperationResp::TCancelOperationResp(const TCancelOperationResp& other275) {
+ status = other275.status;
}
-TCancelOperationResp& TCancelOperationResp::operator=(const TCancelOperationResp& other268) {
- status = other268.status;
+TCancelOperationResp& TCancelOperationResp::operator=(const TCancelOperationResp& other276) {
+ status = other276.status;
return *this;
}
void TCancelOperationResp::printTo(std::ostream& out) const {
@@ -8116,11 +8714,11 @@ void swap(TCloseOperationReq &a, TCloseOperationReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TCloseOperationReq::TCloseOperationReq(const TCloseOperationReq& other269) {
- operationHandle = other269.operationHandle;
+TCloseOperationReq::TCloseOperationReq(const TCloseOperationReq& other277) {
+ operationHandle = other277.operationHandle;
}
-TCloseOperationReq& TCloseOperationReq::operator=(const TCloseOperationReq& other270) {
- operationHandle = other270.operationHandle;
+TCloseOperationReq& TCloseOperationReq::operator=(const TCloseOperationReq& other278) {
+ operationHandle = other278.operationHandle;
return *this;
}
void TCloseOperationReq::printTo(std::ostream& out) const {
@@ -8202,11 +8800,11 @@ void swap(TCloseOperationResp &a, TCloseOperationResp &b) {
swap(a.status, b.status);
}
-TCloseOperationResp::TCloseOperationResp(const TCloseOperationResp& other271) {
- status = other271.status;
+TCloseOperationResp::TCloseOperationResp(const TCloseOperationResp& other279) {
+ status = other279.status;
}
-TCloseOperationResp& TCloseOperationResp::operator=(const TCloseOperationResp& other272) {
- status = other272.status;
+TCloseOperationResp& TCloseOperationResp::operator=(const TCloseOperationResp& other280) {
+ status = other280.status;
return *this;
}
void TCloseOperationResp::printTo(std::ostream& out) const {
@@ -8288,11 +8886,11 @@ void swap(TGetResultSetMetadataReq &a, TGetResultSetMetadataReq &b) {
swap(a.operationHandle, b.operationHandle);
}
-TGetResultSetMetadataReq::TGetResultSetMetadataReq(const TGetResultSetMetadataReq& other273) {
- operationHandle = other273.operationHandle;
+TGetResultSetMetadataReq::TGetResultSetMetadataReq(const TGetResultSetMetadataReq& other281) {
+ operationHandle = other281.operationHandle;
}
-TGetResultSetMetadataReq& TGetResultSetMetadataReq::operator=(const TGetResultSetMetadataReq& other274) {
- operationHandle = other274.operationHandle;
+TGetResultSetMetadataReq& TGetResultSetMetadataReq::operator=(const TGetResultSetMetadataReq& other282) {
+ operationHandle = other282.operationHandle;
return *this;
}
void TGetResultSetMetadataReq::printTo(std::ostream& out) const {
@@ -8394,15 +8992,15 @@ void swap(TGetResultSetMetadataResp &a, TGetResultSetMetadataResp &b) {
swap(a.__isset, b.__isset);
}
-TGetResultSetMetadataResp::TGetResultSetMetadataResp(const TGetResultSetMetadataResp& other275) {
- status = other275.status;
- schema = other275.schema;
- __isset = other275.__isset;
+TGetResultSetMetadataResp::TGetResultSetMetadataResp(const TGetResultSetMetadataResp& other283) {
+ status = other283.status;
+ schema = other283.schema;
+ __isset = other283.__isset;
}
-TGetResultSetMetadataResp& TGetResultSetMetadataResp::operator=(const TGetResultSetMetadataResp& other276) {
- status = other276.status;
- schema = other276.schema;
- __isset = other276.__isset;
+TGetResultSetMetadataResp& TGetResultSetMetadataResp::operator=(const TGetResultSetMetadataResp& other284) {
+ status = other284.status;
+ schema = other284.schema;
+ __isset = other284.__isset;
return *this;
}
void TGetResultSetMetadataResp::printTo(std::ostream& out) const {
@@ -8469,9 +9067,9 @@ uint32_t TFetchResultsReq::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast277;
- xfer += iprot->readI32(ecast277);
- this->orientation = (TFetchOrientation::type)ecast277;
+ int32_t ecast285;
+ xfer += iprot->readI32(ecast285);
+ this->orientation = (TFetchOrientation::type)ecast285;
isset_orientation = true;
} else {
xfer += iprot->skip(ftype);
@@ -8547,19 +9145,19 @@ void swap(TFetchResultsReq &a, TFetchResultsReq &b) {
swap(a.__isset, b.__isset);
}
-TFetchResultsReq::TFetchResultsReq(const TFetchResultsReq& other278) {
- operationHandle = other278.operationHandle;
- orientation = other278.orientation;
- maxRows = other278.maxRows;
- fetchType = other278.fetchType;
- __isset = other278.__isset;
-}
-TFetchResultsReq& TFetchResultsReq::operator=(const TFetchResultsReq& other279) {
- operationHandle = other279.operationHandle;
- orientation = other279.orientation;
- maxRows = other279.maxRows;
- fetchType = other279.fetchType;
- __isset = other279.__isset;
+TFetchResultsReq::TFetchResultsReq(const TFetchResultsReq& other286) {
+ operationHandle = other286.operationHandle;
+ orientation = other286.orientation;
+ maxRows = other286.maxRows;
+ fetchType = other286.fetchType;
+ __isset = other286.__isset;
+}
+TFetchResultsReq& TFetchResultsReq::operator=(const TFetchResultsReq& other287) {
+ operationHandle = other287.operationHandle;
+ orientation = other287.orientation;
+ maxRows = other287.maxRows;
+ fetchType = other287.fetchType;
+ __isset = other287.__isset;
return *this;
}
void TFetchResultsReq::printTo(std::ostream& out) const {
@@ -8683,17 +9281,17 @@ void swap(TFetchResultsResp &a, TFetchResultsResp &b) {
swap(a.__isset, b.__isset);
}
-TFetchResultsResp::TFetchResultsResp(const TFetchResultsResp& other280) {
- status = other280.status;
- hasMoreRows = other280.hasMoreRows;
- results = other280.results;
- __isset = other280.__isset;
-}
-TFetchResultsResp& TFetchResultsResp::operator=(const TFetchResultsResp& other281) {
- status = other281.status;
- hasMoreRows = other281.hasMoreRows;
- results = other281.results;
- __isset = other281.__isset;
+TFetchResultsResp::TFetchResultsResp(const TFetchResultsResp& other288) {
+ status = other288.status;
+ hasMoreRows = other288.hasMoreRows;
+ results = other288.results;
+ __isset = other288.__isset;
+}
+TFetchResultsResp& TFetchResultsResp::operator=(const TFetchResultsResp& other289) {
+ status = other289.status;
+ hasMoreRows = other289.hasMoreRows;
+ results = other289.results;
+ __isset = other289.__isset;
return *this;
}
void TFetchResultsResp::printTo(std::ostream& out) const {
@@ -8817,15 +9415,15 @@ void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b) {
swap(a.renewer, b.renewer);
}
-TGetDelegationTokenReq::TGetDelegationTokenReq(const TGetDelegationTokenReq& other282) {
- sessionHandle = other282.sessionHandle;
- owner = other282.owner;
- renewer = other282.renewer;
+TGetDelegationTokenReq::TGetDelegationTokenReq(const TGetDelegationTokenReq& other290) {
+ sessionHandle = other290.sessionHandle;
+ owner = other290.owner;
+ renewer = other290.renewer;
}
-TGetDelegationTokenReq& TGetDelegationTokenReq::operator=(const TGetDelegationTokenReq& other283) {
- sessionHandle = other283.sessionHandle;
- owner = other283.owner;
- renewer = other283.renewer;
+TGetDelegationTokenReq& TGetDelegationTokenReq::operator=(const TGetDelegationTokenReq& other291) {
+ sessionHandle = other291.sessionHandle;
+ owner = other291.owner;
+ renewer = other291.renewer;
return *this;
}
void TGetDelegationTokenReq::printTo(std::ostream& out) const {
@@ -8929,15 +9527,15 @@ void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b) {
swap(a.__isset, b.__isset);
}
-TGetDelegationTokenResp::TGetDelegationTokenResp(const TGetDelegationTokenResp& other284) {
- status = other284.status;
- delegationToken = other284.delegationToken;
- __isset = other284.__isset;
+TGetDelegationTokenResp::TGetDelegationTokenResp(const TGetDelegationTokenResp& other292) {
+ status = other292.status;
+ delegationToken = other292.delegationToken;
+ __isset = other292.__isset;
}
-TGetDelegationTokenResp& TGetDelegationTokenResp::operator=(const TGetDelegationTokenResp& other285) {
- status = other285.status;
- delegationToken = other285.delegationToken;
- __isset = other285.__isset;
+TGetDelegationTokenResp& TGetDelegationTokenResp::operator=(const TGetDelegationTokenResp& other293) {
+ status = other293.status;
+ delegationToken = other293.delegationToken;
+ __isset = other293.__isset;
return *this;
}
void TGetDelegationTokenResp::printTo(std::ostream& out) const {
@@ -9040,13 +9638,13 @@ void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b) {
swap(a.delegationToken, b.delegationToken);
}
-TCancelDelegationTokenReq::TCancelDelegationTokenReq(const TCancelDelegationTokenReq& other286) {
- sessionHandle = other286.sessionHandle;
- delegationToken = other286.delegationToken;
+TCancelDelegationTokenReq::TCancelDelegationTokenReq(const TCancelDelegationTokenReq& other294) {
+ sessionHandle = other294.sessionHandle;
+ delegationToken = other294.delegationToken;
}
-TCancelDelegationTokenReq& TCancelDelegationTokenReq::operator=(const TCancelDelegationTokenReq& other287) {
- sessionHandle = other287.sessionHandle;
- delegationToken = other287.delegationToken;
+TCancelDelegationTokenReq& TCancelDelegationTokenReq::operator=(const TCancelDelegationTokenReq& other295) {
+ sessionHandle = other295.sessionHandle;
+ delegationToken = other295.delegationToken;
return *this;
}
void TCancelDelegationTokenReq::printTo(std::ostream& out) const {
@@ -9129,11 +9727,11 @@ void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b) {
swap(a.status, b.status);
}
-TCancelDelegationTokenResp::TCancelDelegationTokenResp(const TCancelDelegationTokenResp& other288) {
- status = other288.status;
+TCancelDelegationTokenResp::TCancelDelegationTokenResp(const TCancelDelegationTokenResp& other296) {
+ status = other296.status;
}
-TCancelDelegationTokenResp& TCancelDelegationTokenResp::operator=(const TCancelDelegationTokenResp& other289) {
- status = other289.status;
+TCancelDelegationTokenResp& TCancelDelegationTokenResp::operator=(const TCancelDelegationTokenResp& other297) {
+ status = other297.status;
return *this;
}
void TCancelDelegationTokenResp::printTo(std::ostream& out) const {
@@ -9235,13 +9833,13 @@ void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b) {
swap(a.delegationToken, b.delegationToken);
}
-TRenewDelegationTokenReq::TRenewDelegationTokenReq(const TRenewDelegationTokenReq& other290) {
- sessionHandle = other290.sessionHandle;
- delegationToken = other290.delegationToken;
+TRenewDelegationTokenReq::TRenewDelegationTokenReq(const TRenewDelegationTokenReq& other298) {
+ sessionHandle = other298.sessionHandle;
+ delegationToken = other298.delegationToken;
}
-TRenewDelegationTokenReq& TRenewDelegationTokenReq::operator=(const TRenewDelegationTokenReq& other291) {
- sessionHandle = other291.sessionHandle;
- delegationToken = other291.delegationToken;
+TRenewDelegationTokenReq& TRenewDelegationTokenReq::operator=(const TRenewDelegationTokenReq& other299) {
+ sessionHandle = other299.sessionHandle;
+ delegationToken = other299.delegationToken;
return *this;
}
void TRenewDelegationTokenReq::printTo(std::ostream& out) const {
@@ -9324,11 +9922,11 @@ void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b) {
swap(a.status, b.status);
}
-TRenewDelegationTokenResp::TRenewDelegationTokenResp(const TRenewDelegationTokenResp& other292) {
- status = other292.status;
+TRenewDelegationTokenResp::TRenewDelegationTokenResp(const TRenewDelegationTokenResp& other300) {
+ status = other300.status;
}
-TRenewDelegationTokenResp& TRenewDelegationTokenResp::operator=(const TRenewDelegationTokenResp& other293) {
- status = other293.status;
+TRenewDelegationTokenResp& TRenewDelegationTokenResp::operator=(const TRenewDelegationTokenResp& other301) {
+ status = other301.status;
return *this;
}
void TRenewDelegationTokenResp::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/f13ee089/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
----------------------------------------------------------------------
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 d4b401c..9f937ca 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
@@ -297,6 +297,14 @@ class TGetFunctionsReq;
class TGetFunctionsResp;
+class TGetPrimaryKeysReq;
+
+class TGetPrimaryKeysResp;
+
+class TGetCrossReferenceReq;
+
+class TGetCrossReferenceResp;
+
class TGetOperationStatusReq;
class TGetOperationStatusResp;
@@ -3383,6 +3391,274 @@ inline std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj)
return out;
}
+typedef struct _TGetPrimaryKeysReq__isset {
+ _TGetPrimaryKeysReq__isset() : catalogName(false), schemaName(false), tableName(false) {}
+ bool catalogName :1;
+ bool schemaName :1;
+ bool tableName :1;
+} _TGetPrimaryKeysReq__isset;
+
+class TGetPrimaryKeysReq {
+ public:
+
+ TGetPrimaryKeysReq(const TGetPrimaryKeysReq&);
+ TGetPrimaryKeysReq& operator=(const TGetPrimaryKeysReq&);
+ TGetPrimaryKeysReq() : catalogName(), schemaName(), tableName() {
+ }
+
+ virtual ~TGetPrimaryKeysReq() throw();
+ TSessionHandle sessionHandle;
+ TIdentifier catalogName;
+ TIdentifier schemaName;
+ TIdentifier tableName;
+
+ _TGetPrimaryKeysReq__isset __isset;
+
+ void __set_sessionHandle(const TSessionHandle& val);
+
+ void __set_catalogName(const TIdentifier& val);
+
+ void __set_schemaName(const TIdentifier& val);
+
+ void __set_tableName(const TIdentifier& val);
+
+ bool operator == (const TGetPrimaryKeysReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (__isset.catalogName != rhs.__isset.catalogName)
+ return false;
+ else if (__isset.catalogName && !(catalogName == rhs.catalogName))
+ return false;
+ if (__isset.schemaName != rhs.__isset.schemaName)
+ return false;
+ else if (__isset.schemaName && !(schemaName == rhs.schemaName))
+ return false;
+ if (__isset.tableName != rhs.__isset.tableName)
+ return false;
+ else if (__isset.tableName && !(tableName == rhs.tableName))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetPrimaryKeysReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetPrimaryKeysReq & ) 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(TGetPrimaryKeysReq &a, TGetPrimaryKeysReq &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetPrimaryKeysReq& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _TGetPrimaryKeysResp__isset {
+ _TGetPrimaryKeysResp__isset() : operationHandle(false) {}
+ bool operationHandle :1;
+} _TGetPrimaryKeysResp__isset;
+
+class TGetPrimaryKeysResp {
+ public:
+
+ TGetPrimaryKeysResp(const TGetPrimaryKeysResp&);
+ TGetPrimaryKeysResp& operator=(const TGetPrimaryKeysResp&);
+ TGetPrimaryKeysResp() {
+ }
+
+ virtual ~TGetPrimaryKeysResp() throw();
+ TStatus status;
+ TOperationHandle operationHandle;
+
+ _TGetPrimaryKeysResp__isset __isset;
+
+ void __set_status(const TStatus& val);
+
+ void __set_operationHandle(const TOperationHandle& val);
+
+ bool operator == (const TGetPrimaryKeysResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ if (__isset.operationHandle != rhs.__isset.operationHandle)
+ return false;
+ else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetPrimaryKeysResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetPrimaryKeysResp & ) 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(TGetPrimaryKeysResp &a, TGetPrimaryKeysResp &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetPrimaryKeysResp& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _TGetCrossReferenceReq__isset {
+ _TGetCrossReferenceReq__isset() : parentCatalogName(false), parentSchemaName(false), parentTableName(false), foreignCatalogName(false), foreignSchemaName(false), foreignTableName(false) {}
+ bool parentCatalogName :1;
+ bool parentSchemaName :1;
+ bool parentTableName :1;
+ bool foreignCatalogName :1;
+ bool foreignSchemaName :1;
+ bool foreignTableName :1;
+} _TGetCrossReferenceReq__isset;
+
+class TGetCrossReferenceReq {
+ public:
+
+ TGetCrossReferenceReq(const TGetCrossReferenceReq&);
+ TGetCrossReferenceReq& operator=(const TGetCrossReferenceReq&);
+ TGetCrossReferenceReq() : parentCatalogName(), parentSchemaName(), parentTableName(), foreignCatalogName(), foreignSchemaName(), foreignTableName() {
+ }
+
+ virtual ~TGetCrossReferenceReq() throw();
+ TSessionHandle sessionHandle;
+ TIdentifier parentCatalogName;
+ TIdentifier parentSchemaName;
+ TIdentifier parentTableName;
+ TIdentifier foreignCatalogName;
+ TIdentifier foreignSchemaName;
+ TIdentifier foreignTableName;
+
+ _TGetCrossReferenceReq__isset __isset;
+
+ void __set_sessionHandle(const TSessionHandle& val);
+
+ void __set_parentCatalogName(const TIdentifier& val);
+
+ void __set_parentSchemaName(const TIdentifier& val);
+
+ void __set_parentTableName(const TIdentifier& val);
+
+ void __set_foreignCatalogName(const TIdentifier& val);
+
+ void __set_foreignSchemaName(const TIdentifier& val);
+
+ void __set_foreignTableName(const TIdentifier& val);
+
+ bool operator == (const TGetCrossReferenceReq & rhs) const
+ {
+ if (!(sessionHandle == rhs.sessionHandle))
+ return false;
+ if (__isset.parentCatalogName != rhs.__isset.parentCatalogName)
+ return false;
+ else if (__isset.parentCatalogName && !(parentCatalogName == rhs.parentCatalogName))
+ return false;
+ if (__isset.parentSchemaName != rhs.__isset.parentSchemaName)
+ return false;
+ else if (__isset.parentSchemaName && !(parentSchemaName == rhs.parentSchemaName))
+ return false;
+ if (__isset.parentTableName != rhs.__isset.parentTableName)
+ return false;
+ else if (__isset.parentTableName && !(parentTableName == rhs.parentTableName))
+ return false;
+ if (__isset.foreignCatalogName != rhs.__isset.foreignCatalogName)
+ return false;
+ else if (__isset.foreignCatalogName && !(foreignCatalogName == rhs.foreignCatalogName))
+ return false;
+ if (__isset.foreignSchemaName != rhs.__isset.foreignSchemaName)
+ return false;
+ else if (__isset.foreignSchemaName && !(foreignSchemaName == rhs.foreignSchemaName))
+ return false;
+ if (__isset.foreignTableName != rhs.__isset.foreignTableName)
+ return false;
+ else if (__isset.foreignTableName && !(foreignTableName == rhs.foreignTableName))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetCrossReferenceReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetCrossReferenceReq & ) 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(TGetCrossReferenceReq &a, TGetCrossReferenceReq &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetCrossReferenceReq& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _TGetCrossReferenceResp__isset {
+ _TGetCrossReferenceResp__isset() : operationHandle(false) {}
+ bool operationHandle :1;
+} _TGetCrossReferenceResp__isset;
+
+class TGetCrossReferenceResp {
+ public:
+
+ TGetCrossReferenceResp(const TGetCrossReferenceResp&);
+ TGetCrossReferenceResp& operator=(const TGetCrossReferenceResp&);
+ TGetCrossReferenceResp() {
+ }
+
+ virtual ~TGetCrossReferenceResp() throw();
+ TStatus status;
+ TOperationHandle operationHandle;
+
+ _TGetCrossReferenceResp__isset __isset;
+
+ void __set_status(const TStatus& val);
+
+ void __set_operationHandle(const TOperationHandle& val);
+
+ bool operator == (const TGetCrossReferenceResp & rhs) const
+ {
+ if (!(status == rhs.status))
+ return false;
+ if (__isset.operationHandle != rhs.__isset.operationHandle)
+ return false;
+ else if (__isset.operationHandle && !(operationHandle == rhs.operationHandle))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetCrossReferenceResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetCrossReferenceResp & ) 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(TGetCrossReferenceResp &a, TGetCrossReferenceResp &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetCrossReferenceResp& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
class TGetOperationStatusReq {
public: