hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject [08/12] hive git commit: HIVE-17771 : Implement commands to manage resource plan (Harish Jaiprakash, reviewed by Sergey Shelukhin)
Date Sat, 21 Oct 2017 01:05:05 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/a7e34455/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 d915f3c..f722085 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
@@ -187,6 +187,18 @@ const char* _kClientCapabilityNames[] = {
 };
 const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kClientCapabilityValues, _kClientCapabilityNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
+int _kWMResourcePlanStatusValues[] = {
+  WMResourcePlanStatus::ACTIVE,
+  WMResourcePlanStatus::ENABLED,
+  WMResourcePlanStatus::DISABLED
+};
+const char* _kWMResourcePlanStatusNames[] = {
+  "ACTIVE",
+  "ENABLED",
+  "DISABLED"
+};
+const std::map<int, const char*> _WMResourcePlanStatus_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kWMResourcePlanStatusValues, _kWMResourcePlanStatusNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
 
 Version::~Version() throw() {
 }
@@ -20770,7 +20782,7 @@ void WMResourcePlan::__set_name(const std::string& val) {
   this->name = val;
 }
 
-void WMResourcePlan::__set_status(const std::string& val) {
+void WMResourcePlan::__set_status(const WMResourcePlanStatus::type val) {
   this->status = val;
 __isset.status = true;
 }
@@ -20811,8 +20823,10 @@ uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) {
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->status);
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast863;
+          xfer += iprot->readI32(ecast863);
+          this->status = (WMResourcePlanStatus::type)ecast863;
           this->__isset.status = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -20850,8 +20864,8 @@ uint32_t WMResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldEnd();
 
   if (this->__isset.status) {
-    xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeString(this->status);
+    xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_I32, 2);
+    xfer += oprot->writeI32((int32_t)this->status);
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.queryParallelism) {
@@ -20872,17 +20886,17 @@ void swap(WMResourcePlan &a, WMResourcePlan &b) {
   swap(a.__isset, b.__isset);
 }
 
-WMResourcePlan::WMResourcePlan(const WMResourcePlan& other863) {
-  name = other863.name;
-  status = other863.status;
-  queryParallelism = other863.queryParallelism;
-  __isset = other863.__isset;
-}
-WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other864) {
+WMResourcePlan::WMResourcePlan(const WMResourcePlan& other864) {
   name = other864.name;
   status = other864.status;
   queryParallelism = other864.queryParallelism;
   __isset = other864.__isset;
+}
+WMResourcePlan& WMResourcePlan::operator=(const WMResourcePlan& other865) {
+  name = other865.name;
+  status = other865.status;
+  queryParallelism = other865.queryParallelism;
+  __isset = other865.__isset;
   return *this;
 }
 void WMResourcePlan::printTo(std::ostream& out) const {
@@ -21063,16 +21077,7 @@ void swap(WMPool &a, WMPool &b) {
   swap(a.__isset, b.__isset);
 }
 
-WMPool::WMPool(const WMPool& other865) {
-  resourcePlanName = other865.resourcePlanName;
-  poolName = other865.poolName;
-  parentPoolName = other865.parentPoolName;
-  allocFraction = other865.allocFraction;
-  queryParallelism = other865.queryParallelism;
-  schedulingPolicy = other865.schedulingPolicy;
-  __isset = other865.__isset;
-}
-WMPool& WMPool::operator=(const WMPool& other866) {
+WMPool::WMPool(const WMPool& other866) {
   resourcePlanName = other866.resourcePlanName;
   poolName = other866.poolName;
   parentPoolName = other866.parentPoolName;
@@ -21080,6 +21085,15 @@ WMPool& WMPool::operator=(const WMPool& other866) {
   queryParallelism = other866.queryParallelism;
   schedulingPolicy = other866.schedulingPolicy;
   __isset = other866.__isset;
+}
+WMPool& WMPool::operator=(const WMPool& other867) {
+  resourcePlanName = other867.resourcePlanName;
+  poolName = other867.poolName;
+  parentPoolName = other867.parentPoolName;
+  allocFraction = other867.allocFraction;
+  queryParallelism = other867.queryParallelism;
+  schedulingPolicy = other867.schedulingPolicy;
+  __isset = other867.__isset;
   return *this;
 }
 void WMPool::printTo(std::ostream& out) const {
@@ -21225,19 +21239,19 @@ void swap(WMTrigger &a, WMTrigger &b) {
   swap(a.__isset, b.__isset);
 }
 
-WMTrigger::WMTrigger(const WMTrigger& other867) {
-  resourcePlanName = other867.resourcePlanName;
-  poolName = other867.poolName;
-  triggerExpression = other867.triggerExpression;
-  actionExpression = other867.actionExpression;
-  __isset = other867.__isset;
-}
-WMTrigger& WMTrigger::operator=(const WMTrigger& other868) {
+WMTrigger::WMTrigger(const WMTrigger& other868) {
   resourcePlanName = other868.resourcePlanName;
   poolName = other868.poolName;
   triggerExpression = other868.triggerExpression;
   actionExpression = other868.actionExpression;
   __isset = other868.__isset;
+}
+WMTrigger& WMTrigger::operator=(const WMTrigger& other869) {
+  resourcePlanName = other869.resourcePlanName;
+  poolName = other869.poolName;
+  triggerExpression = other869.triggerExpression;
+  actionExpression = other869.actionExpression;
+  __isset = other869.__isset;
   return *this;
 }
 void WMTrigger::printTo(std::ostream& out) const {
@@ -21401,21 +21415,21 @@ void swap(WMMapping &a, WMMapping &b) {
   swap(a.__isset, b.__isset);
 }
 
-WMMapping::WMMapping(const WMMapping& other869) {
-  resourcePlanName = other869.resourcePlanName;
-  entityType = other869.entityType;
-  entityName = other869.entityName;
-  poolName = other869.poolName;
-  ordering = other869.ordering;
-  __isset = other869.__isset;
-}
-WMMapping& WMMapping::operator=(const WMMapping& other870) {
+WMMapping::WMMapping(const WMMapping& other870) {
   resourcePlanName = other870.resourcePlanName;
   entityType = other870.entityType;
   entityName = other870.entityName;
   poolName = other870.poolName;
   ordering = other870.ordering;
   __isset = other870.__isset;
+}
+WMMapping& WMMapping::operator=(const WMMapping& other871) {
+  resourcePlanName = other871.resourcePlanName;
+  entityType = other871.entityType;
+  entityName = other871.entityName;
+  poolName = other871.poolName;
+  ordering = other871.ordering;
+  __isset = other871.__isset;
   return *this;
 }
 void WMMapping::printTo(std::ostream& out) const {
@@ -21430,15 +21444,16 @@ void WMMapping::printTo(std::ostream& out) const {
 }
 
 
-MetaException::~MetaException() throw() {
+WMCreateResourcePlanRequest::~WMCreateResourcePlanRequest() throw() {
 }
 
 
-void MetaException::__set_message(const std::string& val) {
-  this->message = val;
+void WMCreateResourcePlanRequest::__set_resourcePlan(const WMResourcePlan& val) {
+  this->resourcePlan = val;
+__isset.resourcePlan = true;
 }
 
-uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMCreateResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21460,9 +21475,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->resourcePlan.read(iprot);
+          this->__isset.resourcePlan = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -21479,63 +21494,49 @@ uint32_t MetaException::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t MetaException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMCreateResourcePlanRequest::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("WMCreateResourcePlanRequest");
 
+  if (this->__isset.resourcePlan) {
+    xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->resourcePlan.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(MetaException &a, MetaException &b) {
+void swap(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b) {
   using ::std::swap;
-  swap(a.message, b.message);
+  swap(a.resourcePlan, b.resourcePlan);
   swap(a.__isset, b.__isset);
 }
 
-MetaException::MetaException(const MetaException& other871) : TException() {
-  message = other871.message;
-  __isset = other871.__isset;
-}
-MetaException& MetaException::operator=(const MetaException& other872) {
-  message = other872.message;
+WMCreateResourcePlanRequest::WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest& other872) {
+  resourcePlan = other872.resourcePlan;
   __isset = other872.__isset;
+}
+WMCreateResourcePlanRequest& WMCreateResourcePlanRequest::operator=(const WMCreateResourcePlanRequest& other873) {
+  resourcePlan = other873.resourcePlan;
+  __isset = other873.__isset;
   return *this;
 }
-void MetaException::printTo(std::ostream& out) const {
+void WMCreateResourcePlanRequest::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "MetaException(";
-  out << "message=" << to_string(message);
+  out << "WMCreateResourcePlanRequest(";
+  out << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (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() {
+WMCreateResourcePlanResponse::~WMCreateResourcePlanResponse() throw() {
 }
 
 
-void UnknownTableException::__set_message(const std::string& val) {
-  this->message = val;
-}
-
-uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMCreateResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21554,20 +21555,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();
   }
 
@@ -21576,63 +21564,46 @@ uint32_t UnknownTableException::read(::apache::thrift::protocol::TProtocol* ipro
   return xfer;
 }
 
-uint32_t UnknownTableException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMCreateResourcePlanResponse::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("WMCreateResourcePlanResponse");
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(UnknownTableException &a, UnknownTableException &b) {
+void swap(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b) {
   using ::std::swap;
-  swap(a.message, b.message);
-  swap(a.__isset, b.__isset);
+  (void) a;
+  (void) b;
 }
 
-UnknownTableException::UnknownTableException(const UnknownTableException& other873) : TException() {
-  message = other873.message;
-  __isset = other873.__isset;
+WMCreateResourcePlanResponse::WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse& other874) {
+  (void) other874;
 }
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other874) {
-  message = other874.message;
-  __isset = other874.__isset;
+WMCreateResourcePlanResponse& WMCreateResourcePlanResponse::operator=(const WMCreateResourcePlanResponse& other875) {
+  (void) other875;
   return *this;
 }
-void UnknownTableException::printTo(std::ostream& out) const {
+void WMCreateResourcePlanResponse::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "UnknownTableException(";
-  out << "message=" << to_string(message);
+  out << "WMCreateResourcePlanResponse(";
   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() {
+WMGetResourcePlanRequest::~WMGetResourcePlanRequest() throw() {
 }
 
 
-void UnknownDBException::__set_message(const std::string& val) {
-  this->message = val;
+void WMGetResourcePlanRequest::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+__isset.resourcePlanName = true;
 }
 
-uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMGetResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21655,8 +21626,8 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot)
     {
       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);
         }
@@ -21673,63 +21644,54 @@ uint32_t UnknownDBException::read(::apache::thrift::protocol::TProtocol* iprot)
   return xfer;
 }
 
-uint32_t UnknownDBException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMGetResourcePlanRequest::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("WMGetResourcePlanRequest");
 
+  if (this->__isset.resourcePlanName) {
+    xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->resourcePlanName);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(UnknownDBException &a, UnknownDBException &b) {
+void swap(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b) {
   using ::std::swap;
-  swap(a.message, b.message);
+  swap(a.resourcePlanName, b.resourcePlanName);
   swap(a.__isset, b.__isset);
 }
 
-UnknownDBException::UnknownDBException(const UnknownDBException& other875) : TException() {
-  message = other875.message;
-  __isset = other875.__isset;
-}
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other876) {
-  message = other876.message;
+WMGetResourcePlanRequest::WMGetResourcePlanRequest(const WMGetResourcePlanRequest& other876) {
+  resourcePlanName = other876.resourcePlanName;
   __isset = other876.__isset;
+}
+WMGetResourcePlanRequest& WMGetResourcePlanRequest::operator=(const WMGetResourcePlanRequest& other877) {
+  resourcePlanName = other877.resourcePlanName;
+  __isset = other877.__isset;
   return *this;
 }
-void UnknownDBException::printTo(std::ostream& out) const {
+void WMGetResourcePlanRequest::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "UnknownDBException(";
-  out << "message=" << to_string(message);
+  out << "WMGetResourcePlanRequest(";
+  out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (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() {
+WMGetResourcePlanResponse::~WMGetResourcePlanResponse() throw() {
 }
 
 
-void AlreadyExistsException::__set_message(const std::string& val) {
-  this->message = val;
+void WMGetResourcePlanResponse::__set_resourcePlan(const WMResourcePlan& val) {
+  this->resourcePlan = val;
+__isset.resourcePlan = true;
 }
 
-uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMGetResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21751,9 +21713,9 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr
     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->resourcePlan.read(iprot);
+          this->__isset.resourcePlan = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -21770,63 +21732,49 @@ uint32_t AlreadyExistsException::read(::apache::thrift::protocol::TProtocol* ipr
   return xfer;
 }
 
-uint32_t AlreadyExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMGetResourcePlanResponse::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("WMGetResourcePlanResponse");
 
+  if (this->__isset.resourcePlan) {
+    xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->resourcePlan.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
+void swap(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b) {
   using ::std::swap;
-  swap(a.message, b.message);
+  swap(a.resourcePlan, b.resourcePlan);
   swap(a.__isset, b.__isset);
 }
 
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other877) : TException() {
-  message = other877.message;
-  __isset = other877.__isset;
-}
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other878) {
-  message = other878.message;
+WMGetResourcePlanResponse::WMGetResourcePlanResponse(const WMGetResourcePlanResponse& other878) {
+  resourcePlan = other878.resourcePlan;
   __isset = other878.__isset;
+}
+WMGetResourcePlanResponse& WMGetResourcePlanResponse::operator=(const WMGetResourcePlanResponse& other879) {
+  resourcePlan = other879.resourcePlan;
+  __isset = other879.__isset;
   return *this;
 }
-void AlreadyExistsException::printTo(std::ostream& out) const {
+void WMGetResourcePlanResponse::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "AlreadyExistsException(";
-  out << "message=" << to_string(message);
+  out << "WMGetResourcePlanResponse(";
+  out << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "<null>"));
   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() {
+WMGetAllResourcePlanRequest::~WMGetAllResourcePlanRequest() throw() {
 }
 
 
-void InvalidPartitionException::__set_message(const std::string& val) {
-  this->message = val;
-}
-
-uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMGetAllResourcePlanRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21845,20 +21793,7 @@ uint32_t InvalidPartitionException::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();
   }
 
@@ -21867,63 +21802,46 @@ uint32_t InvalidPartitionException::read(::apache::thrift::protocol::TProtocol*
   return xfer;
 }
 
-uint32_t InvalidPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMGetAllResourcePlanRequest::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("WMGetAllResourcePlanRequest");
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
+void swap(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b) {
   using ::std::swap;
-  swap(a.message, b.message);
-  swap(a.__isset, b.__isset);
+  (void) a;
+  (void) b;
 }
 
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other879) : TException() {
-  message = other879.message;
-  __isset = other879.__isset;
+WMGetAllResourcePlanRequest::WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest& other880) {
+  (void) other880;
 }
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other880) {
-  message = other880.message;
-  __isset = other880.__isset;
+WMGetAllResourcePlanRequest& WMGetAllResourcePlanRequest::operator=(const WMGetAllResourcePlanRequest& other881) {
+  (void) other881;
   return *this;
 }
-void InvalidPartitionException::printTo(std::ostream& out) const {
+void WMGetAllResourcePlanRequest::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "InvalidPartitionException(";
-  out << "message=" << to_string(message);
+  out << "WMGetAllResourcePlanRequest(";
   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() {
+WMGetAllResourcePlanResponse::~WMGetAllResourcePlanResponse() throw() {
 }
 
 
-void UnknownPartitionException::__set_message(const std::string& val) {
-  this->message = val;
+void WMGetAllResourcePlanResponse::__set_resourcePlans(const std::vector<WMResourcePlan> & val) {
+  this->resourcePlans = val;
+__isset.resourcePlans = true;
 }
 
-uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t WMGetAllResourcePlanResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -21945,9 +21863,21 @@ uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol*
     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_LIST) {
+          {
+            this->resourcePlans.clear();
+            uint32_t _size882;
+            ::apache::thrift::protocol::TType _etype885;
+            xfer += iprot->readListBegin(_etype885, _size882);
+            this->resourcePlans.resize(_size882);
+            uint32_t _i886;
+            for (_i886 = 0; _i886 < _size882; ++_i886)
+            {
+              xfer += this->resourcePlans[_i886].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.resourcePlans = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -21964,19 +21894,1097 @@ uint32_t UnknownPartitionException::read(::apache::thrift::protocol::TProtocol*
   return xfer;
 }
 
-uint32_t UnknownPartitionException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t WMGetAllResourcePlanResponse::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;
-}
+  xfer += oprot->writeStructBegin("WMGetAllResourcePlanResponse");
+
+  if (this->__isset.resourcePlans) {
+    xfer += oprot->writeFieldBegin("resourcePlans", ::apache::thrift::protocol::T_LIST, 1);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->resourcePlans.size()));
+      std::vector<WMResourcePlan> ::const_iterator _iter887;
+      for (_iter887 = this->resourcePlans.begin(); _iter887 != this->resourcePlans.end(); ++_iter887)
+      {
+        xfer += (*_iter887).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b) {
+  using ::std::swap;
+  swap(a.resourcePlans, b.resourcePlans);
+  swap(a.__isset, b.__isset);
+}
+
+WMGetAllResourcePlanResponse::WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse& other888) {
+  resourcePlans = other888.resourcePlans;
+  __isset = other888.__isset;
+}
+WMGetAllResourcePlanResponse& WMGetAllResourcePlanResponse::operator=(const WMGetAllResourcePlanResponse& other889) {
+  resourcePlans = other889.resourcePlans;
+  __isset = other889.__isset;
+  return *this;
+}
+void WMGetAllResourcePlanResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMGetAllResourcePlanResponse(";
+  out << "resourcePlans="; (__isset.resourcePlans ? (out << to_string(resourcePlans)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMAlterResourcePlanRequest::~WMAlterResourcePlanRequest() throw() {
+}
+
+
+void WMAlterResourcePlanRequest::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+__isset.resourcePlanName = true;
+}
+
+void WMAlterResourcePlanRequest::__set_resourcePlan(const WMResourcePlan& val) {
+  this->resourcePlan = val;
+__isset.resourcePlan = true;
+}
+
+uint32_t WMAlterResourcePlanRequest::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_STRUCT) {
+          xfer += this->resourcePlan.read(iprot);
+          this->__isset.resourcePlan = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t WMAlterResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMAlterResourcePlanRequest");
+
+  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.resourcePlan) {
+    xfer += oprot->writeFieldBegin("resourcePlan", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->resourcePlan.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.resourcePlan, b.resourcePlan);
+  swap(a.__isset, b.__isset);
+}
+
+WMAlterResourcePlanRequest::WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest& other890) {
+  resourcePlanName = other890.resourcePlanName;
+  resourcePlan = other890.resourcePlan;
+  __isset = other890.__isset;
+}
+WMAlterResourcePlanRequest& WMAlterResourcePlanRequest::operator=(const WMAlterResourcePlanRequest& other891) {
+  resourcePlanName = other891.resourcePlanName;
+  resourcePlan = other891.resourcePlan;
+  __isset = other891.__isset;
+  return *this;
+}
+void WMAlterResourcePlanRequest::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMAlterResourcePlanRequest(";
+  out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "<null>"));
+  out << ", " << "resourcePlan="; (__isset.resourcePlan ? (out << to_string(resourcePlan)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMAlterResourcePlanResponse::~WMAlterResourcePlanResponse() throw() {
+}
+
+
+uint32_t WMAlterResourcePlanResponse::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 WMAlterResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMAlterResourcePlanResponse");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+WMAlterResourcePlanResponse::WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse& other892) {
+  (void) other892;
+}
+WMAlterResourcePlanResponse& WMAlterResourcePlanResponse::operator=(const WMAlterResourcePlanResponse& other893) {
+  (void) other893;
+  return *this;
+}
+void WMAlterResourcePlanResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMAlterResourcePlanResponse(";
+  out << ")";
+}
+
+
+WMValidateResourcePlanRequest::~WMValidateResourcePlanRequest() throw() {
+}
+
+
+void WMValidateResourcePlanRequest::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+__isset.resourcePlanName = true;
+}
+
+uint32_t WMValidateResourcePlanRequest::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;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t WMValidateResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMValidateResourcePlanRequest");
+
+  if (this->__isset.resourcePlanName) {
+    xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->resourcePlanName);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.__isset, b.__isset);
+}
+
+WMValidateResourcePlanRequest::WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest& other894) {
+  resourcePlanName = other894.resourcePlanName;
+  __isset = other894.__isset;
+}
+WMValidateResourcePlanRequest& WMValidateResourcePlanRequest::operator=(const WMValidateResourcePlanRequest& other895) {
+  resourcePlanName = other895.resourcePlanName;
+  __isset = other895.__isset;
+  return *this;
+}
+void WMValidateResourcePlanRequest::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMValidateResourcePlanRequest(";
+  out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMValidateResourcePlanResponse::~WMValidateResourcePlanResponse() throw() {
+}
+
+
+void WMValidateResourcePlanResponse::__set_isValid(const bool val) {
+  this->isValid = val;
+__isset.isValid = true;
+}
+
+uint32_t WMValidateResourcePlanResponse::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_BOOL) {
+          xfer += iprot->readBool(this->isValid);
+          this->__isset.isValid = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t WMValidateResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMValidateResourcePlanResponse");
+
+  if (this->__isset.isValid) {
+    xfer += oprot->writeFieldBegin("isValid", ::apache::thrift::protocol::T_BOOL, 1);
+    xfer += oprot->writeBool(this->isValid);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b) {
+  using ::std::swap;
+  swap(a.isValid, b.isValid);
+  swap(a.__isset, b.__isset);
+}
+
+WMValidateResourcePlanResponse::WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse& other896) {
+  isValid = other896.isValid;
+  __isset = other896.__isset;
+}
+WMValidateResourcePlanResponse& WMValidateResourcePlanResponse::operator=(const WMValidateResourcePlanResponse& other897) {
+  isValid = other897.isValid;
+  __isset = other897.__isset;
+  return *this;
+}
+void WMValidateResourcePlanResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMValidateResourcePlanResponse(";
+  out << "isValid="; (__isset.isValid ? (out << to_string(isValid)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMDropResourcePlanRequest::~WMDropResourcePlanRequest() throw() {
+}
+
+
+void WMDropResourcePlanRequest::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+__isset.resourcePlanName = true;
+}
+
+uint32_t WMDropResourcePlanRequest::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;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t WMDropResourcePlanRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMDropResourcePlanRequest");
+
+  if (this->__isset.resourcePlanName) {
+    xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->resourcePlanName);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.__isset, b.__isset);
+}
+
+WMDropResourcePlanRequest::WMDropResourcePlanRequest(const WMDropResourcePlanRequest& other898) {
+  resourcePlanName = other898.resourcePlanName;
+  __isset = other898.__isset;
+}
+WMDropResourcePlanRequest& WMDropResourcePlanRequest::operator=(const WMDropResourcePlanRequest& other899) {
+  resourcePlanName = other899.resourcePlanName;
+  __isset = other899.__isset;
+  return *this;
+}
+void WMDropResourcePlanRequest::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMDropResourcePlanRequest(";
+  out << "resourcePlanName="; (__isset.resourcePlanName ? (out << to_string(resourcePlanName)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMDropResourcePlanResponse::~WMDropResourcePlanResponse() throw() {
+}
+
+
+uint32_t WMDropResourcePlanResponse::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 WMDropResourcePlanResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMDropResourcePlanResponse");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+WMDropResourcePlanResponse::WMDropResourcePlanResponse(const WMDropResourcePlanResponse& other900) {
+  (void) other900;
+}
+WMDropResourcePlanResponse& WMDropResourcePlanResponse::operator=(const WMDropResourcePlanResponse& other901) {
+  (void) other901;
+  return *this;
+}
+void WMDropResourcePlanResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMDropResourcePlanResponse(";
+  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& other902) : TException() {
+  message = other902.message;
+  __isset = other902.__isset;
+}
+MetaException& MetaException::operator=(const MetaException& other903) {
+  message = other903.message;
+  __isset = other903.__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& other904) : TException() {
+  message = other904.message;
+  __isset = other904.__isset;
+}
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other905) {
+  message = other905.message;
+  __isset = other905.__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& other906) : TException() {
+  message = other906.message;
+  __isset = other906.__isset;
+}
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other907) {
+  message = other907.message;
+  __isset = other907.__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& other908) : TException() {
+  message = other908.message;
+  __isset = other908.__isset;
+}
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other909) {
+  message = other909.message;
+  __isset = other909.__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& other910) : TException() {
+  message = other910.message;
+  __isset = other910.__isset;
+}
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other911) {
+  message = other911.message;
+  __isset = other911.__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;
@@ -21984,13 +22992,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other881) : TException() {
-  message = other881.message;
-  __isset = other881.__isset;
+UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other912) : TException() {
+  message = other912.message;
+  __isset = other912.__isset;
 }
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other882) {
-  message = other882.message;
-  __isset = other882.__isset;
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other913) {
+  message = other913.message;
+  __isset = other913.__isset;
   return *this;
 }
 void UnknownPartitionException::printTo(std::ostream& out) const {
@@ -22081,13 +23089,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other883) : TException() {
-  message = other883.message;
-  __isset = other883.__isset;
+InvalidObjectException::InvalidObjectException(const InvalidObjectException& other914) : TException() {
+  message = other914.message;
+  __isset = other914.__isset;
 }
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other884) {
-  message = other884.message;
-  __isset = other884.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other915) {
+  message = other915.message;
+  __isset = other915.__isset;
   return *this;
 }
 void InvalidObjectException::printTo(std::ostream& out) const {
@@ -22178,13 +23186,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other885) : TException() {
-  message = other885.message;
-  __isset = other885.__isset;
+NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other916) : TException() {
+  message = other916.message;
+  __isset = other916.__isset;
 }
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other886) {
-  message = other886.message;
-  __isset = other886.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other917) {
+  message = other917.message;
+  __isset = other917.__isset;
   return *this;
 }
 void NoSuchObjectException::printTo(std::ostream& out) const {
@@ -22275,13 +23283,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other887) : TException() {
-  message = other887.message;
-  __isset = other887.__isset;
+IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other918) : TException() {
+  message = other918.message;
+  __isset = other918.__isset;
 }
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other888) {
-  message = other888.message;
-  __isset = other888.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other919) {
+  message = other919.message;
+  __isset = other919.__isset;
   return *this;
 }
 void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@ -22372,13 +23380,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other889) : TException() {
-  message = other889.message;
-  __isset = other889.__isset;
+InvalidOperationException::InvalidOperationException(const InvalidOperationException& other920) : TException() {
+  message = other920.message;
+  __isset = other920.__isset;
 }
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other890) {
-  message = other890.message;
-  __isset = other890.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other921) {
+  message = other921.message;
+  __isset = other921.__isset;
   return *this;
 }
 void InvalidOperationException::printTo(std::ostream& out) const {
@@ -22469,13 +23477,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) {
   swap(a.__isset, b.__isset);
 }
 
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other891) : TException() {
-  message = other891.message;
-  __isset = other891.__isset;
+ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other922) : TException() {
+  message = other922.message;
+  __isset = other922.__isset;
 }
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other892) {
-  message = other892.message;
-  __isset = other892.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other923) {
+  message = other923.message;
+  __isset = other923.__isset;
   return *this;
 }
 void ConfigValSecurityException::printTo(std::ostream& out) const {
@@ -22566,13 +23574,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidInputException::InvalidInputException(const InvalidInputException& other893) : TException() {
-  message = other893.message;
-  __isset = other893.__isset;
+InvalidInputException::InvalidInputException(const InvalidInputException& other924) : TException() {
+  message = other924.message;
+  __isset = other924.__isset;
 }
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other894) {
-  message = other894.message;
-  __isset = other894.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other925) {
+  message = other925.message;
+  __isset = other925.__isset;
   return *this;
 }
 void InvalidInputException::printTo(std::ostream& out) const {
@@ -22663,13 +23671,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other895) : TException() {
-  message = other895.message;
-  __isset = other895.__isset;
+NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other926) : TException() {
+  message = other926.message;
+  __isset = other926.__isset;
 }
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other896) {
-  message = other896.message;
-  __isset = other896.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other927) {
+  message = other927.message;
+  __isset = other927.__isset;
   return *this;
 }
 void NoSuchTxnException::printTo(std::ostream& out) const {
@@ -22760,13 +23768,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other897) : TException() {
-  message = other897.message;
-  __isset = other897.__isset;
+TxnAbortedException::TxnAbortedException(const TxnAbortedException& other928) : TException() {
+  message = other928.message;
+  __isset = other928.__isset;
 }
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other898) {
-  message = other898.message;
-  __isset = other898.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other929) {
+  message = other929.message;
+  __isset = other929.__isset;
   return *this;
 }
 void TxnAbortedException::printTo(std::ostream& out) const {
@@ -22857,13 +23865,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnOpenException::TxnOpenException(const TxnOpenException& other899) : TException() {
-  message = other899.message;
-  __isset = other899.__isset;
+TxnOpenException::TxnOpenException(const TxnOpenException& other930) : TException() {
+  message = other930.message;
+  __isset = other930.__isset;
 }
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other900) {
-  message = other900.message;
-  __isset = other900.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other931) {
+  message = other931.message;
+  __isset = other931.__isset;
   return *this;
 }
 void TxnOpenException::printTo(std::ostream& out) const {
@@ -22954,13 +23962,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other901) : TException() {
-  message = other901.message;
-  __isset = other901.__isset;
+NoSuchLockException::NoSuchLockException(const NoSuchLockException& other932) : TException() {
+  message = other932.message;
+  __isset = other932.__isset;
 }
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other902) {
-  message = other902.message;
-  __isset = other902.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other933) {
+  message = other933.message;
+  __isset = other933.__isset;
   return *this;
 }
 void NoSuchLockException::printTo(std::ostream& out) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/a7e34455/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 b552c39..159af47 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
@@ -167,6 +167,16 @@ struct ClientCapability {
 
 extern const std::map<int, const char*> _ClientCapability_VALUES_TO_NAMES;
 
+struct WMResourcePlanStatus {
+  enum type {
+    ACTIVE = 1,
+    ENABLED = 2,
+    DISABLED = 3
+  };
+};
+
+extern const std::map<int, const char*> _WMResourcePlanStatus_VALUES_TO_NAMES;
+
 class Version;
 
 class FieldSchema;
@@ -447,6 +457,30 @@ class WMTrigger;
 
 class WMMapping;
 
+class WMCreateResourcePlanRequest;
+
+class WMCreateResourcePlanResponse;
+
+class WMGetResourcePlanRequest;
+
+class WMGetResourcePlanResponse;
+
+class WMGetAllResourcePlanRequest;
+
+class WMGetAllResourcePlanResponse;
+
+class WMAlterResourcePlanRequest;
+
+class WMAlterResourcePlanResponse;
+
+class WMValidateResourcePlanRequest;
+
+class WMValidateResourcePlanResponse;
+
+class WMDropResourcePlanRequest;
+
+class WMDropResourcePlanResponse;
+
 class MetaException;
 
 class UnknownTableException;
@@ -8461,19 +8495,19 @@ class WMResourcePlan {
 
   WMResourcePlan(const WMResourcePlan&);
   WMResourcePlan& operator=(const WMResourcePlan&);
-  WMResourcePlan() : name(), status(), queryParallelism(0) {
+  WMResourcePlan() : name(), status((WMResourcePlanStatus::type)0), queryParallelism(0) {
   }
 
   virtual ~WMResourcePlan() throw();
   std::string name;
-  std::string status;
+  WMResourcePlanStatus::type status;
   int32_t queryParallelism;
 
   _WMResourcePlan__isset __isset;
 
   void __set_name(const std::string& val);
 
-  void __set_status(const std::string& val);
+  void __set_status(const WMResourcePlanStatus::type val);
 
   void __set_queryParallelism(const int32_t val);
 
@@ -8730,6 +8764,538 @@ inline std::ostream& operator<<(std::ostream& out, const WMMapping& obj)
   return out;
 }
 
+typedef struct _WMCreateResourcePlanRequest__isset {
+  _WMCreateResourcePlanRequest__isset() : resourcePlan(false) {}
+  bool resourcePlan :1;
+} _WMCreateResourcePlanRequest__isset;
+
+class WMCreateResourcePlanRequest {
+ public:
+
+  WMCreateResourcePlanRequest(const WMCreateResourcePlanRequest&);
+  WMCreateResourcePlanRequest& operator=(const WMCreateResourcePlanRequest&);
+  WMCreateResourcePlanRequest() {
+  }
+
+  virtual ~WMCreateResourcePlanRequest() throw();
+  WMResourcePlan resourcePlan;
+
+  _WMCreateResourcePlanRequest__isset __isset;
+
+  void __set_resourcePlan(const WMResourcePlan& val);
+
+  bool operator == (const WMCreateResourcePlanRequest & rhs) const
+  {
+    if (__isset.resourcePlan != rhs.__isset.resourcePlan)
+      return false;
+    else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan))
+      return false;
+    return true;
+  }
+  bool operator != (const WMCreateResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMCreateResourcePlanRequest & ) 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(WMCreateResourcePlanRequest &a, WMCreateResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+class WMCreateResourcePlanResponse {
+ public:
+
+  WMCreateResourcePlanResponse(const WMCreateResourcePlanResponse&);
+  WMCreateResourcePlanResponse& operator=(const WMCreateResourcePlanResponse&);
+  WMCreateResourcePlanResponse() {
+  }
+
+  virtual ~WMCreateResourcePlanResponse() throw();
+
+  bool operator == (const WMCreateResourcePlanResponse & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const WMCreateResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMCreateResourcePlanResponse & ) 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(WMCreateResourcePlanResponse &a, WMCreateResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMCreateResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMGetResourcePlanRequest__isset {
+  _WMGetResourcePlanRequest__isset() : resourcePlanName(false) {}
+  bool resourcePlanName :1;
+} _WMGetResourcePlanRequest__isset;
+
+class WMGetResourcePlanRequest {
+ public:
+
+  WMGetResourcePlanRequest(const WMGetResourcePlanRequest&);
+  WMGetResourcePlanRequest& operator=(const WMGetResourcePlanRequest&);
+  WMGetResourcePlanRequest() : resourcePlanName() {
+  }
+
+  virtual ~WMGetResourcePlanRequest() throw();
+  std::string resourcePlanName;
+
+  _WMGetResourcePlanRequest__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  bool operator == (const WMGetResourcePlanRequest & rhs) const
+  {
+    if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+      return false;
+    else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    return true;
+  }
+  bool operator != (const WMGetResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMGetResourcePlanRequest & ) 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(WMGetResourcePlanRequest &a, WMGetResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMGetResourcePlanResponse__isset {
+  _WMGetResourcePlanResponse__isset() : resourcePlan(false) {}
+  bool resourcePlan :1;
+} _WMGetResourcePlanResponse__isset;
+
+class WMGetResourcePlanResponse {
+ public:
+
+  WMGetResourcePlanResponse(const WMGetResourcePlanResponse&);
+  WMGetResourcePlanResponse& operator=(const WMGetResourcePlanResponse&);
+  WMGetResourcePlanResponse() {
+  }
+
+  virtual ~WMGetResourcePlanResponse() throw();
+  WMResourcePlan resourcePlan;
+
+  _WMGetResourcePlanResponse__isset __isset;
+
+  void __set_resourcePlan(const WMResourcePlan& val);
+
+  bool operator == (const WMGetResourcePlanResponse & rhs) const
+  {
+    if (__isset.resourcePlan != rhs.__isset.resourcePlan)
+      return false;
+    else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan))
+      return false;
+    return true;
+  }
+  bool operator != (const WMGetResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMGetResourcePlanResponse & ) 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(WMGetResourcePlanResponse &a, WMGetResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMGetResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+class WMGetAllResourcePlanRequest {
+ public:
+
+  WMGetAllResourcePlanRequest(const WMGetAllResourcePlanRequest&);
+  WMGetAllResourcePlanRequest& operator=(const WMGetAllResourcePlanRequest&);
+  WMGetAllResourcePlanRequest() {
+  }
+
+  virtual ~WMGetAllResourcePlanRequest() throw();
+
+  bool operator == (const WMGetAllResourcePlanRequest & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const WMGetAllResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMGetAllResourcePlanRequest & ) 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(WMGetAllResourcePlanRequest &a, WMGetAllResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMGetAllResourcePlanResponse__isset {
+  _WMGetAllResourcePlanResponse__isset() : resourcePlans(false) {}
+  bool resourcePlans :1;
+} _WMGetAllResourcePlanResponse__isset;
+
+class WMGetAllResourcePlanResponse {
+ public:
+
+  WMGetAllResourcePlanResponse(const WMGetAllResourcePlanResponse&);
+  WMGetAllResourcePlanResponse& operator=(const WMGetAllResourcePlanResponse&);
+  WMGetAllResourcePlanResponse() {
+  }
+
+  virtual ~WMGetAllResourcePlanResponse() throw();
+  std::vector<WMResourcePlan>  resourcePlans;
+
+  _WMGetAllResourcePlanResponse__isset __isset;
+
+  void __set_resourcePlans(const std::vector<WMResourcePlan> & val);
+
+  bool operator == (const WMGetAllResourcePlanResponse & rhs) const
+  {
+    if (__isset.resourcePlans != rhs.__isset.resourcePlans)
+      return false;
+    else if (__isset.resourcePlans && !(resourcePlans == rhs.resourcePlans))
+      return false;
+    return true;
+  }
+  bool operator != (const WMGetAllResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMGetAllResourcePlanResponse & ) 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(WMGetAllResourcePlanResponse &a, WMGetAllResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMGetAllResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMAlterResourcePlanRequest__isset {
+  _WMAlterResourcePlanRequest__isset() : resourcePlanName(false), resourcePlan(false) {}
+  bool resourcePlanName :1;
+  bool resourcePlan :1;
+} _WMAlterResourcePlanRequest__isset;
+
+class WMAlterResourcePlanRequest {
+ public:
+
+  WMAlterResourcePlanRequest(const WMAlterResourcePlanRequest&);
+  WMAlterResourcePlanRequest& operator=(const WMAlterResourcePlanRequest&);
+  WMAlterResourcePlanRequest() : resourcePlanName() {
+  }
+
+  virtual ~WMAlterResourcePlanRequest() throw();
+  std::string resourcePlanName;
+  WMResourcePlan resourcePlan;
+
+  _WMAlterResourcePlanRequest__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  void __set_resourcePlan(const WMResourcePlan& val);
+
+  bool operator == (const WMAlterResourcePlanRequest & rhs) const
+  {
+    if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+      return false;
+    else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    if (__isset.resourcePlan != rhs.__isset.resourcePlan)
+      return false;
+    else if (__isset.resourcePlan && !(resourcePlan == rhs.resourcePlan))
+      return false;
+    return true;
+  }
+  bool operator != (const WMAlterResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMAlterResourcePlanRequest & ) 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(WMAlterResourcePlanRequest &a, WMAlterResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+class WMAlterResourcePlanResponse {
+ public:
+
+  WMAlterResourcePlanResponse(const WMAlterResourcePlanResponse&);
+  WMAlterResourcePlanResponse& operator=(const WMAlterResourcePlanResponse&);
+  WMAlterResourcePlanResponse() {
+  }
+
+  virtual ~WMAlterResourcePlanResponse() throw();
+
+  bool operator == (const WMAlterResourcePlanResponse & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const WMAlterResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMAlterResourcePlanResponse & ) 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(WMAlterResourcePlanResponse &a, WMAlterResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMAlterResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMValidateResourcePlanRequest__isset {
+  _WMValidateResourcePlanRequest__isset() : resourcePlanName(false) {}
+  bool resourcePlanName :1;
+} _WMValidateResourcePlanRequest__isset;
+
+class WMValidateResourcePlanRequest {
+ public:
+
+  WMValidateResourcePlanRequest(const WMValidateResourcePlanRequest&);
+  WMValidateResourcePlanRequest& operator=(const WMValidateResourcePlanRequest&);
+  WMValidateResourcePlanRequest() : resourcePlanName() {
+  }
+
+  virtual ~WMValidateResourcePlanRequest() throw();
+  std::string resourcePlanName;
+
+  _WMValidateResourcePlanRequest__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  bool operator == (const WMValidateResourcePlanRequest & rhs) const
+  {
+    if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+      return false;
+    else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    return true;
+  }
+  bool operator != (const WMValidateResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMValidateResourcePlanRequest & ) 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(WMValidateResourcePlanRequest &a, WMValidateResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMValidateResourcePlanResponse__isset {
+  _WMValidateResourcePlanResponse__isset() : isValid(false) {}
+  bool isValid :1;
+} _WMValidateResourcePlanResponse__isset;
+
+class WMValidateResourcePlanResponse {
+ public:
+
+  WMValidateResourcePlanResponse(const WMValidateResourcePlanResponse&);
+  WMValidateResourcePlanResponse& operator=(const WMValidateResourcePlanResponse&);
+  WMValidateResourcePlanResponse() : isValid(0) {
+  }
+
+  virtual ~WMValidateResourcePlanResponse() throw();
+  bool isValid;
+
+  _WMValidateResourcePlanResponse__isset __isset;
+
+  void __set_isValid(const bool val);
+
+  bool operator == (const WMValidateResourcePlanResponse & rhs) const
+  {
+    if (__isset.isValid != rhs.__isset.isValid)
+      return false;
+    else if (__isset.isValid && !(isValid == rhs.isValid))
+      return false;
+    return true;
+  }
+  bool operator != (const WMValidateResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMValidateResourcePlanResponse & ) 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(WMValidateResourcePlanResponse &a, WMValidateResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMValidateResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMDropResourcePlanRequest__isset {
+  _WMDropResourcePlanRequest__isset() : resourcePlanName(false) {}
+  bool resourcePlanName :1;
+} _WMDropResourcePlanRequest__isset;
+
+class WMDropResourcePlanRequest {
+ public:
+
+  WMDropResourcePlanRequest(const WMDropResourcePlanRequest&);
+  WMDropResourcePlanRequest& operator=(const WMDropResourcePlanRequest&);
+  WMDropResourcePlanRequest() : resourcePlanName() {
+  }
+
+  virtual ~WMDropResourcePlanRequest() throw();
+  std::string resourcePlanName;
+
+  _WMDropResourcePlanRequest__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  bool operator == (const WMDropResourcePlanRequest & rhs) const
+  {
+    if (__isset.resourcePlanName != rhs.__isset.resourcePlanName)
+      return false;
+    else if (__isset.resourcePlanName && !(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    return true;
+  }
+  bool operator != (const WMDropResourcePlanRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMDropResourcePlanRequest & ) 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(WMDropResourcePlanRequest &a, WMDropResourcePlanRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+class WMDropResourcePlanResponse {
+ public:
+
+  WMDropResourcePlanResponse(const WMDropResourcePlanResponse&);
+  WMDropResourcePlanResponse& operator=(const WMDropResourcePlanResponse&);
+  WMDropResourcePlanResponse() {
+  }
+
+  virtual ~WMDropResourcePlanResponse() throw();
+
+  bool operator == (const WMDropResourcePlanResponse & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const WMDropResourcePlanResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMDropResourcePlanResponse & ) 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(WMDropResourcePlanResponse &a, WMDropResourcePlanResponse &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMDropResourcePlanResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message :1;


Mime
View raw message