You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2017/11/27 22:28:03 UTC
[09/13] hive git commit: HIVE-17954 : Implement pool, user,
group and trigger to pool management API's (Harish Jaiprakash,
reviewed by Sergey Shelukhin)
http://git-wip-us.apache.org/repos/asf/hive/blob/44ef5991/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index c0ad739..8524dbd 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -21281,9 +21281,9 @@ void WMMapping::__set_entityName(const std::string& val) {
this->entityName = val;
}
-void WMMapping::__set_poolName(const std::string& val) {
- this->poolName = val;
-__isset.poolName = true;
+void WMMapping::__set_poolPath(const std::string& val) {
+ this->poolPath = val;
+__isset.poolPath = true;
}
void WMMapping::__set_ordering(const int32_t val) {
@@ -21341,8 +21341,8 @@ uint32_t WMMapping::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->poolName);
- this->__isset.poolName = true;
+ xfer += iprot->readString(this->poolPath);
+ this->__isset.poolPath = true;
} else {
xfer += iprot->skip(ftype);
}
@@ -21390,9 +21390,9 @@ uint32_t WMMapping::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeString(this->entityName);
xfer += oprot->writeFieldEnd();
- if (this->__isset.poolName) {
- xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 4);
- xfer += oprot->writeString(this->poolName);
+ if (this->__isset.poolPath) {
+ xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->poolPath);
xfer += oprot->writeFieldEnd();
}
if (this->__isset.ordering) {
@@ -21410,7 +21410,7 @@ void swap(WMMapping &a, WMMapping &b) {
swap(a.resourcePlanName, b.resourcePlanName);
swap(a.entityType, b.entityType);
swap(a.entityName, b.entityName);
- swap(a.poolName, b.poolName);
+ swap(a.poolPath, b.poolPath);
swap(a.ordering, b.ordering);
swap(a.__isset, b.__isset);
}
@@ -21419,7 +21419,7 @@ WMMapping::WMMapping(const WMMapping& other870) {
resourcePlanName = other870.resourcePlanName;
entityType = other870.entityType;
entityName = other870.entityName;
- poolName = other870.poolName;
+ poolPath = other870.poolPath;
ordering = other870.ordering;
__isset = other870.__isset;
}
@@ -21427,7 +21427,7 @@ WMMapping& WMMapping::operator=(const WMMapping& other871) {
resourcePlanName = other871.resourcePlanName;
entityType = other871.entityType;
entityName = other871.entityName;
- poolName = other871.poolName;
+ poolPath = other871.poolPath;
ordering = other871.ordering;
__isset = other871.__isset;
return *this;
@@ -21438,7 +21438,7 @@ void WMMapping::printTo(std::ostream& out) const {
out << "resourcePlanName=" << to_string(resourcePlanName);
out << ", " << "entityType=" << to_string(entityType);
out << ", " << "entityName=" << to_string(entityName);
- out << ", " << "poolName="; (__isset.poolName ? (out << to_string(poolName)) : (out << "<null>"));
+ out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "<null>"));
out << ", " << "ordering="; (__isset.ordering ? (out << to_string(ordering)) : (out << "<null>"));
out << ")";
}
@@ -23671,15 +23671,16 @@ void WMGetTriggersForResourePlanResponse::printTo(std::ostream& out) const {
}
-MetaException::~MetaException() throw() {
+WMCreatePoolRequest::~WMCreatePoolRequest() throw() {
}
-void MetaException::__set_message(const std::string& val) {
- this->message = val;
+void WMCreatePoolRequest::__set_pool(const WMPool& val) {
+ this->pool = val;
+__isset.pool = true;
}
-uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMCreatePoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -23701,9 +23702,9 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) {
switch (fid)
{
case 1:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->pool.read(iprot);
+ this->__isset.pool = true;
} else {
xfer += iprot->skip(ftype);
}
@@ -23720,63 +23721,49 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) {
return xfer;
}
-uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMCreatePoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("MetaException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMCreatePoolRequest");
+ if (this->__isset.pool) {
+ xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->pool.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(MetaException &a, MetaException &b) {
+void swap(WMCreatePoolRequest &a, WMCreatePoolRequest &b) {
using ::std::swap;
- swap(a.message, b.message);
+ swap(a.pool, b.pool);
swap(a.__isset, b.__isset);
}
-MetaException::MetaException(const MetaException& other956) : TException() {
- message = other956.message;
+WMCreatePoolRequest::WMCreatePoolRequest(const WMCreatePoolRequest& other956) {
+ pool = other956.pool;
__isset = other956.__isset;
}
-MetaException& MetaException::operator=(const MetaException& other957) {
- message = other957.message;
+WMCreatePoolRequest& WMCreatePoolRequest::operator=(const WMCreatePoolRequest& other957) {
+ pool = other957.pool;
__isset = other957.__isset;
return *this;
}
-void MetaException::printTo(std::ostream& out) const {
+void WMCreatePoolRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "MetaException(";
- out << "message=" << to_string(message);
+ out << "WMCreatePoolRequest(";
+ out << "pool="; (__isset.pool ? (out << to_string(pool)) : (out << "<null>"));
out << ")";
}
-const char* MetaException::what() const throw() {
- try {
- std::stringstream ss;
- ss << "TException - service has thrown: " << *this;
- this->thriftTExceptionMessageHolder_ = ss.str();
- return this->thriftTExceptionMessageHolder_.c_str();
- } catch (const std::exception&) {
- return "TException - service has thrown: MetaException";
- }
-}
-
-UnknownTableException::~UnknownTableException() throw() {
+WMCreatePoolResponse::~WMCreatePoolResponse() throw() {
}
-void UnknownTableException::__set_message(const std::string& val) {
- this->message = val;
-}
-
-uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMCreatePoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -23795,20 +23782,7 @@ uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* ipro
if (ftype == ::apache::thrift::protocol::T_STOP) {
break;
}
- switch (fid)
- {
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
+ xfer += iprot->skip(ftype);
xfer += iprot->readFieldEnd();
}
@@ -23817,63 +23791,51 @@ uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* ipro
return xfer;
}
-uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMCreatePoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("UnknownTableException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMCreatePoolResponse");
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(UnknownTableException &a, UnknownTableException &b) {
+void swap(WMCreatePoolResponse &a, WMCreatePoolResponse &b) {
using ::std::swap;
- swap(a.message, b.message);
- swap(a.__isset, b.__isset);
+ (void) a;
+ (void) b;
}
-UnknownTableException::UnknownTableException(const UnknownTableException& other958) : TException() {
- message = other958.message;
- __isset = other958.__isset;
+WMCreatePoolResponse::WMCreatePoolResponse(const WMCreatePoolResponse& other958) {
+ (void) other958;
}
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other959) {
- message = other959.message;
- __isset = other959.__isset;
+WMCreatePoolResponse& WMCreatePoolResponse::operator=(const WMCreatePoolResponse& other959) {
+ (void) other959;
return *this;
}
-void UnknownTableException::printTo(std::ostream& out) const {
+void WMCreatePoolResponse::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "UnknownTableException(";
- out << "message=" << to_string(message);
+ out << "WMCreatePoolResponse(";
out << ")";
}
-const char* UnknownTableException::what() const throw() {
- try {
- std::stringstream ss;
- ss << "TException - service has thrown: " << *this;
- this->thriftTExceptionMessageHolder_ = ss.str();
- return this->thriftTExceptionMessageHolder_.c_str();
- } catch (const std::exception&) {
- return "TException - service has thrown: UnknownTableException";
- }
+
+WMAlterPoolRequest::~WMAlterPoolRequest() throw() {
}
-UnknownDBException::~UnknownDBException() throw() {
+void WMAlterPoolRequest::__set_pool(const WMPool& val) {
+ this->pool = val;
+__isset.pool = true;
}
-
-void UnknownDBException::__set_message(const std::string& val) {
- this->message = val;
+void WMAlterPoolRequest::__set_poolPath(const std::string& val) {
+ this->poolPath = val;
+__isset.poolPath = true;
}
-uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMAlterPoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -23895,9 +23857,17 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot)
switch (fid)
{
case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->pool.read(iprot);
+ this->__isset.pool = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
+ xfer += iprot->readString(this->poolPath);
+ this->__isset.poolPath = true;
} else {
xfer += iprot->skip(ftype);
}
@@ -23914,63 +23884,58 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot)
return xfer;
}
-uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMAlterPoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("UnknownDBException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMAlterPoolRequest");
+ if (this->__isset.pool) {
+ xfer += oprot->writeFieldBegin("pool", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->pool.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.poolPath) {
+ xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->poolPath);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(UnknownDBException &a, UnknownDBException &b) {
+void swap(WMAlterPoolRequest &a, WMAlterPoolRequest &b) {
using ::std::swap;
- swap(a.message, b.message);
+ swap(a.pool, b.pool);
+ swap(a.poolPath, b.poolPath);
swap(a.__isset, b.__isset);
}
-UnknownDBException::UnknownDBException(const UnknownDBException& other960) : TException() {
- message = other960.message;
+WMAlterPoolRequest::WMAlterPoolRequest(const WMAlterPoolRequest& other960) {
+ pool = other960.pool;
+ poolPath = other960.poolPath;
__isset = other960.__isset;
}
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other961) {
- message = other961.message;
+WMAlterPoolRequest& WMAlterPoolRequest::operator=(const WMAlterPoolRequest& other961) {
+ pool = other961.pool;
+ poolPath = other961.poolPath;
__isset = other961.__isset;
return *this;
}
-void UnknownDBException::printTo(std::ostream& out) const {
+void WMAlterPoolRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "UnknownDBException(";
- out << "message=" << to_string(message);
+ out << "WMAlterPoolRequest(";
+ out << "pool="; (__isset.pool ? (out << to_string(pool)) : (out << "<null>"));
+ out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "<null>"));
out << ")";
}
-const char* UnknownDBException::what() const throw() {
- try {
- std::stringstream ss;
- ss << "TException - service has thrown: " << *this;
- this->thriftTExceptionMessageHolder_ = ss.str();
- return this->thriftTExceptionMessageHolder_.c_str();
- } catch (const std::exception&) {
- return "TException - service has thrown: UnknownDBException";
- }
-}
-
-AlreadyExistsException::~AlreadyExistsException() throw() {
+WMAlterPoolResponse::~WMAlterPoolResponse() throw() {
}
-void AlreadyExistsException::__set_message(const std::string& val) {
- this->message = val;
-}
-
-uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMAlterPoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -23989,20 +23954,7 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_STOP) {
break;
}
- switch (fid)
- {
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
+ xfer += iprot->skip(ftype);
xfer += iprot->readFieldEnd();
}
@@ -24011,63 +23963,51 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr
return xfer;
}
-uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMAlterPoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("AlreadyExistsException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMAlterPoolResponse");
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
+void swap(WMAlterPoolResponse &a, WMAlterPoolResponse &b) {
using ::std::swap;
- swap(a.message, b.message);
- swap(a.__isset, b.__isset);
+ (void) a;
+ (void) b;
}
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other962) : TException() {
- message = other962.message;
- __isset = other962.__isset;
+WMAlterPoolResponse::WMAlterPoolResponse(const WMAlterPoolResponse& other962) {
+ (void) other962;
}
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other963) {
- message = other963.message;
- __isset = other963.__isset;
+WMAlterPoolResponse& WMAlterPoolResponse::operator=(const WMAlterPoolResponse& other963) {
+ (void) other963;
return *this;
}
-void AlreadyExistsException::printTo(std::ostream& out) const {
+void WMAlterPoolResponse::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "AlreadyExistsException(";
- out << "message=" << to_string(message);
+ out << "WMAlterPoolResponse(";
out << ")";
}
-const char* AlreadyExistsException::what() const throw() {
- try {
- std::stringstream ss;
- ss << "TException - service has thrown: " << *this;
- this->thriftTExceptionMessageHolder_ = ss.str();
- return this->thriftTExceptionMessageHolder_.c_str();
- } catch (const std::exception&) {
- return "TException - service has thrown: AlreadyExistsException";
- }
+
+WMDropPoolRequest::~WMDropPoolRequest() throw() {
}
-InvalidPartitionException::~InvalidPartitionException() throw() {
+void WMDropPoolRequest::__set_resourcePlanName(const std::string& val) {
+ this->resourcePlanName = val;
+__isset.resourcePlanName = true;
}
-
-void InvalidPartitionException::__set_message(const std::string& val) {
- this->message = val;
+void WMDropPoolRequest::__set_poolPath(const std::string& val) {
+ this->poolPath = val;
+__isset.poolPath = true;
}
-uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMDropPoolRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -24090,8 +24030,16 @@ uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol*
{
case 1:
if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
+ xfer += iprot->readString(this->resourcePlanName);
+ this->__isset.resourcePlanName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->poolPath);
+ this->__isset.poolPath = true;
} else {
xfer += iprot->skip(ftype);
}
@@ -24108,63 +24056,58 @@ uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol*
return xfer;
}
-uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMDropPoolRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("InvalidPartitionException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMDropPoolRequest");
+ if (this->__isset.resourcePlanName) {
+ xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->resourcePlanName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.poolPath) {
+ xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->poolPath);
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
+void swap(WMDropPoolRequest &a, WMDropPoolRequest &b) {
using ::std::swap;
- swap(a.message, b.message);
+ swap(a.resourcePlanName, b.resourcePlanName);
+ swap(a.poolPath, b.poolPath);
swap(a.__isset, b.__isset);
}
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other964) : TException() {
- message = other964.message;
+WMDropPoolRequest::WMDropPoolRequest(const WMDropPoolRequest& other964) {
+ resourcePlanName = other964.resourcePlanName;
+ poolPath = other964.poolPath;
__isset = other964.__isset;
}
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other965) {
- message = other965.message;
+WMDropPoolRequest& WMDropPoolRequest::operator=(const WMDropPoolRequest& other965) {
+ resourcePlanName = other965.resourcePlanName;
+ poolPath = other965.poolPath;
__isset = other965.__isset;
return *this;
}
-void InvalidPartitionException::printTo(std::ostream& out) const {
+void WMDropPoolRequest::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "InvalidPartitionException(";
- out << "message=" << to_string(message);
+ out << "WMDropPoolRequest(";
+ out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "<null>"));
+ out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "<null>"));
out << ")";
}
-const char* InvalidPartitionException::what() const throw() {
- try {
- std::stringstream ss;
- ss << "TException - service has thrown: " << *this;
- this->thriftTExceptionMessageHolder_ = ss.str();
- return this->thriftTExceptionMessageHolder_.c_str();
- } catch (const std::exception&) {
- return "TException - service has thrown: InvalidPartitionException";
- }
-}
-
-UnknownPartitionException::~UnknownPartitionException() throw() {
+WMDropPoolResponse::~WMDropPoolResponse() throw() {
}
-void UnknownPartitionException::__set_message(const std::string& val) {
- this->message = val;
-}
-
-uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMDropPoolResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
uint32_t xfer = 0;
@@ -24183,20 +24126,7 @@ uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_STOP) {
break;
}
- switch (fid)
- {
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->message);
- this->__isset.message = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
+ xfer += iprot->skip(ftype);
xfer += iprot->readFieldEnd();
}
@@ -24205,38 +24135,1140 @@ uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol*
return xfer;
}
-uint32_t UnknownPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMDropPoolResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
uint32_t xfer = 0;
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("UnknownPartitionException");
-
- xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->message);
- xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeStructBegin("WMDropPoolResponse");
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
}
-void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
+void swap(WMDropPoolResponse &a, WMDropPoolResponse &b) {
using ::std::swap;
- swap(a.message, b.message);
- swap(a.__isset, b.__isset);
+ (void) a;
+ (void) b;
}
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other966) : TException() {
- message = other966.message;
- __isset = other966.__isset;
+WMDropPoolResponse::WMDropPoolResponse(const WMDropPoolResponse& other966) {
+ (void) other966;
}
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other967) {
- message = other967.message;
- __isset = other967.__isset;
+WMDropPoolResponse& WMDropPoolResponse::operator=(const WMDropPoolResponse& other967) {
+ (void) other967;
return *this;
}
-void UnknownPartitionException::printTo(std::ostream& out) const {
+void WMDropPoolResponse::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
- out << "UnknownPartitionException(";
+ out << "WMDropPoolResponse(";
+ out << ")";
+}
+
+
+WMCreateOrUpdateMappingRequest::~WMCreateOrUpdateMappingRequest() throw() {
+}
+
+
+void WMCreateOrUpdateMappingRequest::__set_mapping(const WMMapping& val) {
+ this->mapping = val;
+__isset.mapping = true;
+}
+
+void WMCreateOrUpdateMappingRequest::__set_update(const bool val) {
+ this->update = val;
+__isset.update = true;
+}
+
+uint32_t WMCreateOrUpdateMappingRequest::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->mapping.read(iprot);
+ this->__isset.mapping = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->update);
+ this->__isset.update = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMCreateOrUpdateMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingRequest");
+
+ if (this->__isset.mapping) {
+ xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->mapping.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.update) {
+ xfer += oprot->writeFieldBegin("update", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->update);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b) {
+ using ::std::swap;
+ swap(a.mapping, b.mapping);
+ swap(a.update, b.update);
+ swap(a.__isset, b.__isset);
+}
+
+WMCreateOrUpdateMappingRequest::WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest& other968) {
+ mapping = other968.mapping;
+ update = other968.update;
+ __isset = other968.__isset;
+}
+WMCreateOrUpdateMappingRequest& WMCreateOrUpdateMappingRequest::operator=(const WMCreateOrUpdateMappingRequest& other969) {
+ mapping = other969.mapping;
+ update = other969.update;
+ __isset = other969.__isset;
+ return *this;
+}
+void WMCreateOrUpdateMappingRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMCreateOrUpdateMappingRequest(";
+ out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "<null>"));
+ out << ", " << "update="; (__isset.update ? (out << to_string(update)) : (out << "<null>"));
+ out << ")";
+}
+
+
+WMCreateOrUpdateMappingResponse::~WMCreateOrUpdateMappingResponse() throw() {
+}
+
+
+uint32_t WMCreateOrUpdateMappingResponse::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;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMCreateOrUpdateMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMCreateOrUpdateMappingResponse");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
+WMCreateOrUpdateMappingResponse::WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse& other970) {
+ (void) other970;
+}
+WMCreateOrUpdateMappingResponse& WMCreateOrUpdateMappingResponse::operator=(const WMCreateOrUpdateMappingResponse& other971) {
+ (void) other971;
+ return *this;
+}
+void WMCreateOrUpdateMappingResponse::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMCreateOrUpdateMappingResponse(";
+ out << ")";
+}
+
+
+WMDropMappingRequest::~WMDropMappingRequest() throw() {
+}
+
+
+void WMDropMappingRequest::__set_mapping(const WMMapping& val) {
+ this->mapping = val;
+__isset.mapping = true;
+}
+
+uint32_t WMDropMappingRequest::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->mapping.read(iprot);
+ this->__isset.mapping = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMDropMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMDropMappingRequest");
+
+ if (this->__isset.mapping) {
+ xfer += oprot->writeFieldBegin("mapping", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->mapping.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMDropMappingRequest &a, WMDropMappingRequest &b) {
+ using ::std::swap;
+ swap(a.mapping, b.mapping);
+ swap(a.__isset, b.__isset);
+}
+
+WMDropMappingRequest::WMDropMappingRequest(const WMDropMappingRequest& other972) {
+ mapping = other972.mapping;
+ __isset = other972.__isset;
+}
+WMDropMappingRequest& WMDropMappingRequest::operator=(const WMDropMappingRequest& other973) {
+ mapping = other973.mapping;
+ __isset = other973.__isset;
+ return *this;
+}
+void WMDropMappingRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMDropMappingRequest(";
+ out << "mapping="; (__isset.mapping ? (out << to_string(mapping)) : (out << "<null>"));
+ out << ")";
+}
+
+
+WMDropMappingResponse::~WMDropMappingResponse() throw() {
+}
+
+
+uint32_t WMDropMappingResponse::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;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMDropMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMDropMappingResponse");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMDropMappingResponse &a, WMDropMappingResponse &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
+WMDropMappingResponse::WMDropMappingResponse(const WMDropMappingResponse& other974) {
+ (void) other974;
+}
+WMDropMappingResponse& WMDropMappingResponse::operator=(const WMDropMappingResponse& other975) {
+ (void) other975;
+ return *this;
+}
+void WMDropMappingResponse::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMDropMappingResponse(";
+ out << ")";
+}
+
+
+WMCreateOrDropTriggerToPoolMappingRequest::~WMCreateOrDropTriggerToPoolMappingRequest() throw() {
+}
+
+
+void WMCreateOrDropTriggerToPoolMappingRequest::__set_resourcePlanName(const std::string& val) {
+ this->resourcePlanName = val;
+__isset.resourcePlanName = true;
+}
+
+void WMCreateOrDropTriggerToPoolMappingRequest::__set_triggerName(const std::string& val) {
+ this->triggerName = val;
+__isset.triggerName = true;
+}
+
+void WMCreateOrDropTriggerToPoolMappingRequest::__set_poolPath(const std::string& val) {
+ this->poolPath = val;
+__isset.poolPath = true;
+}
+
+void WMCreateOrDropTriggerToPoolMappingRequest::__set_drop(const bool val) {
+ this->drop = val;
+__isset.drop = true;
+}
+
+uint32_t WMCreateOrDropTriggerToPoolMappingRequest::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_STRING) {
+ xfer += iprot->readString(this->resourcePlanName);
+ this->__isset.resourcePlanName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->triggerName);
+ this->__isset.triggerName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->poolPath);
+ this->__isset.poolPath = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->drop);
+ this->__isset.drop = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMCreateOrDropTriggerToPoolMappingRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingRequest");
+
+ if (this->__isset.resourcePlanName) {
+ xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->resourcePlanName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.triggerName) {
+ xfer += oprot->writeFieldBegin("triggerName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->triggerName);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.poolPath) {
+ xfer += oprot->writeFieldBegin("poolPath", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->poolPath);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.drop) {
+ xfer += oprot->writeFieldBegin("drop", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->drop);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b) {
+ using ::std::swap;
+ swap(a.resourcePlanName, b.resourcePlanName);
+ swap(a.triggerName, b.triggerName);
+ swap(a.poolPath, b.poolPath);
+ swap(a.drop, b.drop);
+ swap(a.__isset, b.__isset);
+}
+
+WMCreateOrDropTriggerToPoolMappingRequest::WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest& other976) {
+ resourcePlanName = other976.resourcePlanName;
+ triggerName = other976.triggerName;
+ poolPath = other976.poolPath;
+ drop = other976.drop;
+ __isset = other976.__isset;
+}
+WMCreateOrDropTriggerToPoolMappingRequest& WMCreateOrDropTriggerToPoolMappingRequest::operator=(const WMCreateOrDropTriggerToPoolMappingRequest& other977) {
+ resourcePlanName = other977.resourcePlanName;
+ triggerName = other977.triggerName;
+ poolPath = other977.poolPath;
+ drop = other977.drop;
+ __isset = other977.__isset;
+ return *this;
+}
+void WMCreateOrDropTriggerToPoolMappingRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMCreateOrDropTriggerToPoolMappingRequest(";
+ out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "<null>"));
+ out << ", " << "triggerName="; (__isset.triggerName ? (out << to_string(triggerName)) : (out << "<null>"));
+ out << ", " << "poolPath="; (__isset.poolPath ? (out << to_string(poolPath)) : (out << "<null>"));
+ out << ", " << "drop="; (__isset.drop ? (out << to_string(drop)) : (out << "<null>"));
+ out << ")";
+}
+
+
+WMCreateOrDropTriggerToPoolMappingResponse::~WMCreateOrDropTriggerToPoolMappingResponse() throw() {
+}
+
+
+uint32_t WMCreateOrDropTriggerToPoolMappingResponse::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;
+ }
+ xfer += iprot->skip(ftype);
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t WMCreateOrDropTriggerToPoolMappingResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WMCreateOrDropTriggerToPoolMappingResponse");
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b) {
+ using ::std::swap;
+ (void) a;
+ (void) b;
+}
+
+WMCreateOrDropTriggerToPoolMappingResponse::WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse& other978) {
+ (void) other978;
+}
+WMCreateOrDropTriggerToPoolMappingResponse& WMCreateOrDropTriggerToPoolMappingResponse::operator=(const WMCreateOrDropTriggerToPoolMappingResponse& other979) {
+ (void) other979;
+ return *this;
+}
+void WMCreateOrDropTriggerToPoolMappingResponse::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WMCreateOrDropTriggerToPoolMappingResponse(";
+ out << ")";
+}
+
+
+MetaException::~MetaException() throw() {
+}
+
+
+void MetaException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t MetaException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("MetaException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(MetaException &a, MetaException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+MetaException::MetaException(const MetaException& other980) : TException() {
+ message = other980.message;
+ __isset = other980.__isset;
+}
+MetaException& MetaException::operator=(const MetaException& other981) {
+ message = other981.message;
+ __isset = other981.__isset;
+ return *this;
+}
+void MetaException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "MetaException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* MetaException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: MetaException";
+ }
+}
+
+
+UnknownTableException::~UnknownTableException() throw() {
+}
+
+
+void UnknownTableException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t UnknownTableException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("UnknownTableException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(UnknownTableException &a, UnknownTableException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+UnknownTableException::UnknownTableException(const UnknownTableException& other982) : TException() {
+ message = other982.message;
+ __isset = other982.__isset;
+}
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other983) {
+ message = other983.message;
+ __isset = other983.__isset;
+ return *this;
+}
+void UnknownTableException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "UnknownTableException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* UnknownTableException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: UnknownTableException";
+ }
+}
+
+
+UnknownDBException::~UnknownDBException() throw() {
+}
+
+
+void UnknownDBException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t UnknownDBException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("UnknownDBException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(UnknownDBException &a, UnknownDBException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+UnknownDBException::UnknownDBException(const UnknownDBException& other984) : TException() {
+ message = other984.message;
+ __isset = other984.__isset;
+}
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other985) {
+ message = other985.message;
+ __isset = other985.__isset;
+ return *this;
+}
+void UnknownDBException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "UnknownDBException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* UnknownDBException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: UnknownDBException";
+ }
+}
+
+
+AlreadyExistsException::~AlreadyExistsException() throw() {
+}
+
+
+void AlreadyExistsException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t AlreadyExistsException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("AlreadyExistsException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other986) : TException() {
+ message = other986.message;
+ __isset = other986.__isset;
+}
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other987) {
+ message = other987.message;
+ __isset = other987.__isset;
+ return *this;
+}
+void AlreadyExistsException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "AlreadyExistsException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* AlreadyExistsException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: AlreadyExistsException";
+ }
+}
+
+
+InvalidPartitionException::~InvalidPartitionException() throw() {
+}
+
+
+void InvalidPartitionException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t InvalidPartitionException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("InvalidPartitionException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other988) : TException() {
+ message = other988.message;
+ __isset = other988.__isset;
+}
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other989) {
+ message = other989.message;
+ __isset = other989.__isset;
+ return *this;
+}
+void InvalidPartitionException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "InvalidPartitionException(";
+ out << "message=" << to_string(message);
+ out << ")";
+}
+
+const char* InvalidPartitionException::what() const throw() {
+ try {
+ std::stringstream ss;
+ ss << "TException - service has thrown: " << *this;
+ this->thriftTExceptionMessageHolder_ = ss.str();
+ return this->thriftTExceptionMessageHolder_.c_str();
+ } catch (const std::exception&) {
+ return "TException - service has thrown: InvalidPartitionException";
+ }
+}
+
+
+UnknownPartitionException::~UnknownPartitionException() throw() {
+}
+
+
+void UnknownPartitionException::__set_message(const std::string& val) {
+ this->message = val;
+}
+
+uint32_t UnknownPartitionException::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_STRING) {
+ xfer += iprot->readString(this->message);
+ this->__isset.message = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t UnknownPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("UnknownPartitionException");
+
+ xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->message);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
+ using ::std::swap;
+ swap(a.message, b.message);
+ swap(a.__isset, b.__isset);
+}
+
+UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other990) : TException() {
+ message = other990.message;
+ __isset = other990.__isset;
+}
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other991) {
+ message = other991.message;
+ __isset = other991.__isset;
+ return *this;
+}
+void UnknownPartitionException::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "UnknownPartitionException(";
out << "message=" << to_string(message);
out << ")";
}
@@ -24322,13 +25354,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) {
swap(a.__isset, b.__isset);
}
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other968) : TException() {
- message = other968.message;
- __isset = other968.__isset;
+InvalidObjectException::InvalidObjectException(const InvalidObjectException& other992) : TException() {
+ message = other992.message;
+ __isset = other992.__isset;
}
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other969) {
- message = other969.message;
- __isset = other969.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other993) {
+ message = other993.message;
+ __isset = other993.__isset;
return *this;
}
void InvalidObjectException::printTo(std::ostream& out) const {
@@ -24419,13 +25451,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) {
swap(a.__isset, b.__isset);
}
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other970) : TException() {
- message = other970.message;
- __isset = other970.__isset;
+NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other994) : TException() {
+ message = other994.message;
+ __isset = other994.__isset;
}
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other971) {
- message = other971.message;
- __isset = other971.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other995) {
+ message = other995.message;
+ __isset = other995.__isset;
return *this;
}
void NoSuchObjectException::printTo(std::ostream& out) const {
@@ -24516,13 +25548,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) {
swap(a.__isset, b.__isset);
}
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other972) : TException() {
- message = other972.message;
- __isset = other972.__isset;
+IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other996) : TException() {
+ message = other996.message;
+ __isset = other996.__isset;
}
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other973) {
- message = other973.message;
- __isset = other973.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other997) {
+ message = other997.message;
+ __isset = other997.__isset;
return *this;
}
void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@ -24613,13 +25645,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) {
swap(a.__isset, b.__isset);
}
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other974) : TException() {
- message = other974.message;
- __isset = other974.__isset;
+InvalidOperationException::InvalidOperationException(const InvalidOperationException& other998) : TException() {
+ message = other998.message;
+ __isset = other998.__isset;
}
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other975) {
- message = other975.message;
- __isset = other975.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other999) {
+ message = other999.message;
+ __isset = other999.__isset;
return *this;
}
void InvalidOperationException::printTo(std::ostream& out) const {
@@ -24710,13 +25742,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) {
swap(a.__isset, b.__isset);
}
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other976) : TException() {
- message = other976.message;
- __isset = other976.__isset;
+ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other1000) : TException() {
+ message = other1000.message;
+ __isset = other1000.__isset;
}
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other977) {
- message = other977.message;
- __isset = other977.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other1001) {
+ message = other1001.message;
+ __isset = other1001.__isset;
return *this;
}
void ConfigValSecurityException::printTo(std::ostream& out) const {
@@ -24807,13 +25839,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) {
swap(a.__isset, b.__isset);
}
-InvalidInputException::InvalidInputException(const InvalidInputException& other978) : TException() {
- message = other978.message;
- __isset = other978.__isset;
+InvalidInputException::InvalidInputException(const InvalidInputException& other1002) : TException() {
+ message = other1002.message;
+ __isset = other1002.__isset;
}
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other979) {
- message = other979.message;
- __isset = other979.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other1003) {
+ message = other1003.message;
+ __isset = other1003.__isset;
return *this;
}
void InvalidInputException::printTo(std::ostream& out) const {
@@ -24904,13 +25936,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) {
swap(a.__isset, b.__isset);
}
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other980) : TException() {
- message = other980.message;
- __isset = other980.__isset;
+NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other1004) : TException() {
+ message = other1004.message;
+ __isset = other1004.__isset;
}
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other981) {
- message = other981.message;
- __isset = other981.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other1005) {
+ message = other1005.message;
+ __isset = other1005.__isset;
return *this;
}
void NoSuchTxnException::printTo(std::ostream& out) const {
@@ -25001,13 +26033,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) {
swap(a.__isset, b.__isset);
}
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other982) : TException() {
- message = other982.message;
- __isset = other982.__isset;
+TxnAbortedException::TxnAbortedException(const TxnAbortedException& other1006) : TException() {
+ message = other1006.message;
+ __isset = other1006.__isset;
}
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other983) {
- message = other983.message;
- __isset = other983.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other1007) {
+ message = other1007.message;
+ __isset = other1007.__isset;
return *this;
}
void TxnAbortedException::printTo(std::ostream& out) const {
@@ -25098,13 +26130,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) {
swap(a.__isset, b.__isset);
}
-TxnOpenException::TxnOpenException(const TxnOpenException& other984) : TException() {
- message = other984.message;
- __isset = other984.__isset;
+TxnOpenException::TxnOpenException(const TxnOpenException& other1008) : TException() {
+ message = other1008.message;
+ __isset = other1008.__isset;
}
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other985) {
- message = other985.message;
- __isset = other985.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other1009) {
+ message = other1009.message;
+ __isset = other1009.__isset;
return *this;
}
void TxnOpenException::printTo(std::ostream& out) const {
@@ -25195,13 +26227,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) {
swap(a.__isset, b.__isset);
}
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other986) : TException() {
- message = other986.message;
- __isset = other986.__isset;
+NoSuchLockException::NoSuchLockException(const NoSuchLockException& other1010) : TException() {
+ message = other1010.message;
+ __isset = other1010.__isset;
}
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other987) {
- message = other987.message;
- __isset = other987.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other1011) {
+ message = other1011.message;
+ __isset = other1011.__isset;
return *this;
}
void NoSuchLockException::printTo(std::ostream& out) const {
http://git-wip-us.apache.org/repos/asf/hive/blob/44ef5991/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index cdf0570..9cd7793 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -505,6 +505,30 @@ class WMGetTriggersForResourePlanRequest;
class WMGetTriggersForResourePlanResponse;
+class WMCreatePoolRequest;
+
+class WMCreatePoolResponse;
+
+class WMAlterPoolRequest;
+
+class WMAlterPoolResponse;
+
+class WMDropPoolRequest;
+
+class WMDropPoolResponse;
+
+class WMCreateOrUpdateMappingRequest;
+
+class WMCreateOrUpdateMappingResponse;
+
+class WMDropMappingRequest;
+
+class WMDropMappingResponse;
+
+class WMCreateOrDropTriggerToPoolMappingRequest;
+
+class WMCreateOrDropTriggerToPoolMappingResponse;
+
class MetaException;
class UnknownTableException;
@@ -8718,8 +8742,8 @@ inline std::ostream& operator<<(std::ostream& out, const WMTrigger& obj)
}
typedef struct _WMMapping__isset {
- _WMMapping__isset() : poolName(false), ordering(false) {}
- bool poolName :1;
+ _WMMapping__isset() : poolPath(false), ordering(false) {}
+ bool poolPath :1;
bool ordering :1;
} _WMMapping__isset;
@@ -8728,14 +8752,14 @@ class WMMapping {
WMMapping(const WMMapping&);
WMMapping& operator=(const WMMapping&);
- WMMapping() : resourcePlanName(), entityType(), entityName(), poolName(), ordering(0) {
+ WMMapping() : resourcePlanName(), entityType(), entityName(), poolPath(), ordering(0) {
}
virtual ~WMMapping() throw();
std::string resourcePlanName;
std::string entityType;
std::string entityName;
- std::string poolName;
+ std::string poolPath;
int32_t ordering;
_WMMapping__isset __isset;
@@ -8746,7 +8770,7 @@ class WMMapping {
void __set_entityName(const std::string& val);
- void __set_poolName(const std::string& val);
+ void __set_poolPath(const std::string& val);
void __set_ordering(const int32_t val);
@@ -8758,9 +8782,9 @@ class WMMapping {
return false;
if (!(entityName == rhs.entityName))
return false;
- if (__isset.poolName != rhs.__isset.poolName)
+ if (__isset.poolPath != rhs.__isset.poolPath)
return false;
- else if (__isset.poolName && !(poolName == rhs.poolName))
+ else if (__isset.poolPath && !(poolPath == rhs.poolPath))
return false;
if (__isset.ordering != rhs.__isset.ordering)
return false;
@@ -9896,6 +9920,552 @@ inline std::ostream& operator<<(std::ostream& out, const WMGetTriggersForResoure
return out;
}
+typedef struct _WMCreatePoolRequest__isset {
+ _WMCreatePoolRequest__isset() : pool(false) {}
+ bool pool :1;
+} _WMCreatePoolRequest__isset;
+
+class WMCreatePoolRequest {
+ public:
+
+ WMCreatePoolRequest(const WMCreatePoolRequest&);
+ WMCreatePoolRequest& operator=(const WMCreatePoolRequest&);
+ WMCreatePoolRequest() {
+ }
+
+ virtual ~WMCreatePoolRequest() throw();
+ WMPool pool;
+
+ _WMCreatePoolRequest__isset __isset;
+
+ void __set_pool(const WMPool& val);
+
+ bool operator == (const WMCreatePoolRequest & rhs) const
+ {
+ if (__isset.pool != rhs.__isset.pool)
+ return false;
+ else if (__isset.pool && !(pool == rhs.pool))
+ return false;
+ return true;
+ }
+ bool operator != (const WMCreatePoolRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreatePoolRequest & ) 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(WMCreatePoolRequest &a, WMCreatePoolRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreatePoolRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMCreatePoolResponse {
+ public:
+
+ WMCreatePoolResponse(const WMCreatePoolResponse&);
+ WMCreatePoolResponse& operator=(const WMCreatePoolResponse&);
+ WMCreatePoolResponse() {
+ }
+
+ virtual ~WMCreatePoolResponse() throw();
+
+ bool operator == (const WMCreatePoolResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMCreatePoolResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreatePoolResponse & ) 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(WMCreatePoolResponse &a, WMCreatePoolResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreatePoolResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _WMAlterPoolRequest__isset {
+ _WMAlterPoolRequest__isset() : pool(false), poolPath(false) {}
+ bool pool :1;
+ bool poolPath :1;
+} _WMAlterPoolRequest__isset;
+
+class WMAlterPoolRequest {
+ public:
+
+ WMAlterPoolRequest(const WMAlterPoolRequest&);
+ WMAlterPoolRequest& operator=(const WMAlterPoolRequest&);
+ WMAlterPoolRequest() : poolPath() {
+ }
+
+ virtual ~WMAlterPoolRequest() throw();
+ WMPool pool;
+ std::string poolPath;
+
+ _WMAlterPoolRequest__isset __isset;
+
+ void __set_pool(const WMPool& val);
+
+ void __set_poolPath(const std::string& val);
+
+ bool operator == (const WMAlterPoolRequest & rhs) const
+ {
+ if (__isset.pool != rhs.__isset.pool)
+ return false;
+ else if (__isset.pool && !(pool == rhs.pool))
+ return false;
+ if (__isset.poolPath != rhs.__isset.poolPath)
+ return false;
+ else if (__isset.poolPath && !(poolPath == rhs.poolPath))
+ return false;
+ return true;
+ }
+ bool operator != (const WMAlterPoolRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMAlterPoolRequest & ) 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(WMAlterPoolRequest &a, WMAlterPoolRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMAlterPoolRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMAlterPoolResponse {
+ public:
+
+ WMAlterPoolResponse(const WMAlterPoolResponse&);
+ WMAlterPoolResponse& operator=(const WMAlterPoolResponse&);
+ WMAlterPoolResponse() {
+ }
+
+ virtual ~WMAlterPoolResponse() throw();
+
+ bool operator == (const WMAlterPoolResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMAlterPoolResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMAlterPoolResponse & ) 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(WMAlterPoolResponse &a, WMAlterPoolResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMAlterPoolResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _WMDropPoolRequest__isset {
+ _WMDropPoolRequest__isset() : resourcePlanName(false), poolPath(false) {}
+ bool resourcePlanName :1;
+ bool poolPath :1;
+} _WMDropPoolRequest__isset;
+
+class WMDropPoolRequest {
+ public:
+
+ WMDropPoolRequest(const WMDropPoolRequest&);
+ WMDropPoolRequest& operator=(const WMDropPoolRequest&);
+ WMDropPoolRequest() : resourcePlanName(), poolPath() {
+ }
+
+ virtual ~WMDropPoolRequest() throw();
+ std::string resourcePlanName;
+ std::string poolPath;
+
+ _WMDropPoolRequest__isset __isset;
+
+ void __set_resourcePlanName(const std::string& val);
+
+ void __set_poolPath(const std::string& val);
+
+ bool operator == (const WMDropPoolRequest & rhs) const
+ {
+ if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+ return false;
+ else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+ return false;
+ if (__isset.poolPath != rhs.__isset.poolPath)
+ return false;
+ else if (__isset.poolPath && !(poolPath == rhs.poolPath))
+ return false;
+ return true;
+ }
+ bool operator != (const WMDropPoolRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMDropPoolRequest & ) 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(WMDropPoolRequest &a, WMDropPoolRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropPoolRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMDropPoolResponse {
+ public:
+
+ WMDropPoolResponse(const WMDropPoolResponse&);
+ WMDropPoolResponse& operator=(const WMDropPoolResponse&);
+ WMDropPoolResponse() {
+ }
+
+ virtual ~WMDropPoolResponse() throw();
+
+ bool operator == (const WMDropPoolResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMDropPoolResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMDropPoolResponse & ) 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(WMDropPoolResponse &a, WMDropPoolResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropPoolResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _WMCreateOrUpdateMappingRequest__isset {
+ _WMCreateOrUpdateMappingRequest__isset() : mapping(false), update(false) {}
+ bool mapping :1;
+ bool update :1;
+} _WMCreateOrUpdateMappingRequest__isset;
+
+class WMCreateOrUpdateMappingRequest {
+ public:
+
+ WMCreateOrUpdateMappingRequest(const WMCreateOrUpdateMappingRequest&);
+ WMCreateOrUpdateMappingRequest& operator=(const WMCreateOrUpdateMappingRequest&);
+ WMCreateOrUpdateMappingRequest() : update(0) {
+ }
+
+ virtual ~WMCreateOrUpdateMappingRequest() throw();
+ WMMapping mapping;
+ bool update;
+
+ _WMCreateOrUpdateMappingRequest__isset __isset;
+
+ void __set_mapping(const WMMapping& val);
+
+ void __set_update(const bool val);
+
+ bool operator == (const WMCreateOrUpdateMappingRequest & rhs) const
+ {
+ if (__isset.mapping != rhs.__isset.mapping)
+ return false;
+ else if (__isset.mapping && !(mapping == rhs.mapping))
+ return false;
+ if (__isset.update != rhs.__isset.update)
+ return false;
+ else if (__isset.update && !(update == rhs.update))
+ return false;
+ return true;
+ }
+ bool operator != (const WMCreateOrUpdateMappingRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreateOrUpdateMappingRequest & ) 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(WMCreateOrUpdateMappingRequest &a, WMCreateOrUpdateMappingRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMCreateOrUpdateMappingResponse {
+ public:
+
+ WMCreateOrUpdateMappingResponse(const WMCreateOrUpdateMappingResponse&);
+ WMCreateOrUpdateMappingResponse& operator=(const WMCreateOrUpdateMappingResponse&);
+ WMCreateOrUpdateMappingResponse() {
+ }
+
+ virtual ~WMCreateOrUpdateMappingResponse() throw();
+
+ bool operator == (const WMCreateOrUpdateMappingResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMCreateOrUpdateMappingResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreateOrUpdateMappingResponse & ) 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(WMCreateOrUpdateMappingResponse &a, WMCreateOrUpdateMappingResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateOrUpdateMappingResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _WMDropMappingRequest__isset {
+ _WMDropMappingRequest__isset() : mapping(false) {}
+ bool mapping :1;
+} _WMDropMappingRequest__isset;
+
+class WMDropMappingRequest {
+ public:
+
+ WMDropMappingRequest(const WMDropMappingRequest&);
+ WMDropMappingRequest& operator=(const WMDropMappingRequest&);
+ WMDropMappingRequest() {
+ }
+
+ virtual ~WMDropMappingRequest() throw();
+ WMMapping mapping;
+
+ _WMDropMappingRequest__isset __isset;
+
+ void __set_mapping(const WMMapping& val);
+
+ bool operator == (const WMDropMappingRequest & rhs) const
+ {
+ if (__isset.mapping != rhs.__isset.mapping)
+ return false;
+ else if (__isset.mapping && !(mapping == rhs.mapping))
+ return false;
+ return true;
+ }
+ bool operator != (const WMDropMappingRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMDropMappingRequest & ) 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(WMDropMappingRequest &a, WMDropMappingRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropMappingRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMDropMappingResponse {
+ public:
+
+ WMDropMappingResponse(const WMDropMappingResponse&);
+ WMDropMappingResponse& operator=(const WMDropMappingResponse&);
+ WMDropMappingResponse() {
+ }
+
+ virtual ~WMDropMappingResponse() throw();
+
+ bool operator == (const WMDropMappingResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMDropMappingResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMDropMappingResponse & ) 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(WMDropMappingResponse &a, WMDropMappingResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropMappingResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+typedef struct _WMCreateOrDropTriggerToPoolMappingRequest__isset {
+ _WMCreateOrDropTriggerToPoolMappingRequest__isset() : resourcePlanName(false), triggerName(false), poolPath(false), drop(false) {}
+ bool resourcePlanName :1;
+ bool triggerName :1;
+ bool poolPath :1;
+ bool drop :1;
+} _WMCreateOrDropTriggerToPoolMappingRequest__isset;
+
+class WMCreateOrDropTriggerToPoolMappingRequest {
+ public:
+
+ WMCreateOrDropTriggerToPoolMappingRequest(const WMCreateOrDropTriggerToPoolMappingRequest&);
+ WMCreateOrDropTriggerToPoolMappingRequest& operator=(const WMCreateOrDropTriggerToPoolMappingRequest&);
+ WMCreateOrDropTriggerToPoolMappingRequest() : resourcePlanName(), triggerName(), poolPath(), drop(0) {
+ }
+
+ virtual ~WMCreateOrDropTriggerToPoolMappingRequest() throw();
+ std::string resourcePlanName;
+ std::string triggerName;
+ std::string poolPath;
+ bool drop;
+
+ _WMCreateOrDropTriggerToPoolMappingRequest__isset __isset;
+
+ void __set_resourcePlanName(const std::string& val);
+
+ void __set_triggerName(const std::string& val);
+
+ void __set_poolPath(const std::string& val);
+
+ void __set_drop(const bool val);
+
+ bool operator == (const WMCreateOrDropTriggerToPoolMappingRequest & rhs) const
+ {
+ if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+ return false;
+ else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+ return false;
+ if (__isset.triggerName != rhs.__isset.triggerName)
+ return false;
+ else if (__isset.triggerName && !(triggerName == rhs.triggerName))
+ return false;
+ if (__isset.poolPath != rhs.__isset.poolPath)
+ return false;
+ else if (__isset.poolPath && !(poolPath == rhs.poolPath))
+ return false;
+ if (__isset.drop != rhs.__isset.drop)
+ return false;
+ else if (__isset.drop && !(drop == rhs.drop))
+ return false;
+ return true;
+ }
+ bool operator != (const WMCreateOrDropTriggerToPoolMappingRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreateOrDropTriggerToPoolMappingRequest & ) 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(WMCreateOrDropTriggerToPoolMappingRequest &a, WMCreateOrDropTriggerToPoolMappingRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingRequest& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class WMCreateOrDropTriggerToPoolMappingResponse {
+ public:
+
+ WMCreateOrDropTriggerToPoolMappingResponse(const WMCreateOrDropTriggerToPoolMappingResponse&);
+ WMCreateOrDropTriggerToPoolMappingResponse& operator=(const WMCreateOrDropTriggerToPoolMappingResponse&);
+ WMCreateOrDropTriggerToPoolMappingResponse() {
+ }
+
+ virtual ~WMCreateOrDropTriggerToPoolMappingResponse() throw();
+
+ bool operator == (const WMCreateOrDropTriggerToPoolMappingResponse & /* rhs */) const
+ {
+ return true;
+ }
+ bool operator != (const WMCreateOrDropTriggerToPoolMappingResponse &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const WMCreateOrDropTriggerToPoolMappingResponse & ) 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(WMCreateOrDropTriggerToPoolMappingResponse &a, WMCreateOrDropTriggerToPoolMappingResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerToPoolMappingResponse& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
typedef struct _MetaException__isset {
_MetaException__isset() : message(false) {}
bool message :1;