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: