hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject [3/5] hive git commit: HIVE-17566 : Create schema required for workload management (Harish Jaiprakash, reviewed Prasanth Jayachandran and Sergey Shelukhin)
Date Sat, 07 Oct 2017 01:16:56 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/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 b3c9798..79da92e 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
@@ -20760,6 +20760,674 @@ void TableMeta::printTo(std::ostream& out) const {
 }
 
 
+WMResourcePlan::~WMResourcePlan() throw() {
+}
+
+
+void WMResourcePlan::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void WMResourcePlan::__set_status(const std::string& val) {
+  this->status = val;
+__isset.status = true;
+}
+
+void WMResourcePlan::__set_queryParallelism(const int32_t val) {
+  this->queryParallelism = val;
+__isset.queryParallelism = true;
+}
+
+uint32_t WMResourcePlan::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_name = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->name);
+          isset_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->status);
+          this->__isset.status = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->queryParallelism);
+          this->__isset.queryParallelism = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_name)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WMResourcePlan::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMResourcePlan");
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.status) {
+    xfer += oprot->writeFieldBegin("status", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->status);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.queryParallelism) {
+    xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 3);
+    xfer += oprot->writeI32(this->queryParallelism);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMResourcePlan &a, WMResourcePlan &b) {
+  using ::std::swap;
+  swap(a.name, b.name);
+  swap(a.status, b.status);
+  swap(a.queryParallelism, b.queryParallelism);
+  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) {
+  name = other864.name;
+  status = other864.status;
+  queryParallelism = other864.queryParallelism;
+  __isset = other864.__isset;
+  return *this;
+}
+void WMResourcePlan::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMResourcePlan(";
+  out << "name=" << to_string(name);
+  out << ", " << "status="; (__isset.status ? (out << to_string(status)) : (out << "<null>"));
+  out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMPool::~WMPool() throw() {
+}
+
+
+void WMPool::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+}
+
+void WMPool::__set_poolName(const std::string& val) {
+  this->poolName = val;
+}
+
+void WMPool::__set_parentPoolName(const std::string& val) {
+  this->parentPoolName = val;
+__isset.parentPoolName = true;
+}
+
+void WMPool::__set_allocFraction(const double val) {
+  this->allocFraction = val;
+__isset.allocFraction = true;
+}
+
+void WMPool::__set_queryParallelism(const int32_t val) {
+  this->queryParallelism = val;
+__isset.queryParallelism = true;
+}
+
+void WMPool::__set_schedulingPolicy(const std::string& val) {
+  this->schedulingPolicy = val;
+__isset.schedulingPolicy = true;
+}
+
+uint32_t WMPool::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_resourcePlanName = false;
+  bool isset_poolName = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->resourcePlanName);
+          isset_resourcePlanName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->poolName);
+          isset_poolName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->parentPoolName);
+          this->__isset.parentPoolName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->allocFraction);
+          this->__isset.allocFraction = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->queryParallelism);
+          this->__isset.queryParallelism = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->schedulingPolicy);
+          this->__isset.schedulingPolicy = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_resourcePlanName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_poolName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WMPool::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMPool");
+
+  xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->resourcePlanName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->poolName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.parentPoolName) {
+    xfer += oprot->writeFieldBegin("parentPoolName", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->parentPoolName);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.allocFraction) {
+    xfer += oprot->writeFieldBegin("allocFraction", ::apache::thrift::protocol::T_DOUBLE, 4);
+    xfer += oprot->writeDouble(this->allocFraction);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.queryParallelism) {
+    xfer += oprot->writeFieldBegin("queryParallelism", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32(this->queryParallelism);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.schedulingPolicy) {
+    xfer += oprot->writeFieldBegin("schedulingPolicy", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->schedulingPolicy);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMPool &a, WMPool &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.poolName, b.poolName);
+  swap(a.parentPoolName, b.parentPoolName);
+  swap(a.allocFraction, b.allocFraction);
+  swap(a.queryParallelism, b.queryParallelism);
+  swap(a.schedulingPolicy, b.schedulingPolicy);
+  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) {
+  resourcePlanName = other866.resourcePlanName;
+  poolName = other866.poolName;
+  parentPoolName = other866.parentPoolName;
+  allocFraction = other866.allocFraction;
+  queryParallelism = other866.queryParallelism;
+  schedulingPolicy = other866.schedulingPolicy;
+  __isset = other866.__isset;
+  return *this;
+}
+void WMPool::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMPool(";
+  out << "resourcePlanName=" << to_string(resourcePlanName);
+  out << ", " << "poolName=" << to_string(poolName);
+  out << ", " << "parentPoolName="; (__isset.parentPoolName ? (out << to_string(parentPoolName)) : (out << "<null>"));
+  out << ", " << "allocFraction="; (__isset.allocFraction ? (out << to_string(allocFraction)) : (out << "<null>"));
+  out << ", " << "queryParallelism="; (__isset.queryParallelism ? (out << to_string(queryParallelism)) : (out << "<null>"));
+  out << ", " << "schedulingPolicy="; (__isset.schedulingPolicy ? (out << to_string(schedulingPolicy)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMTrigger::~WMTrigger() throw() {
+}
+
+
+void WMTrigger::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+}
+
+void WMTrigger::__set_poolName(const std::string& val) {
+  this->poolName = val;
+}
+
+void WMTrigger::__set_triggerExpression(const std::string& val) {
+  this->triggerExpression = val;
+__isset.triggerExpression = true;
+}
+
+void WMTrigger::__set_actionExpression(const std::string& val) {
+  this->actionExpression = val;
+__isset.actionExpression = true;
+}
+
+uint32_t WMTrigger::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_resourcePlanName = false;
+  bool isset_poolName = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->resourcePlanName);
+          isset_resourcePlanName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->poolName);
+          isset_poolName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->triggerExpression);
+          this->__isset.triggerExpression = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->actionExpression);
+          this->__isset.actionExpression = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_resourcePlanName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_poolName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WMTrigger::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMTrigger");
+
+  xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->resourcePlanName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("poolName", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->poolName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.triggerExpression) {
+    xfer += oprot->writeFieldBegin("triggerExpression", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->triggerExpression);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.actionExpression) {
+    xfer += oprot->writeFieldBegin("actionExpression", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeString(this->actionExpression);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMTrigger &a, WMTrigger &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.poolName, b.poolName);
+  swap(a.triggerExpression, b.triggerExpression);
+  swap(a.actionExpression, b.actionExpression);
+  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) {
+  resourcePlanName = other868.resourcePlanName;
+  poolName = other868.poolName;
+  triggerExpression = other868.triggerExpression;
+  actionExpression = other868.actionExpression;
+  __isset = other868.__isset;
+  return *this;
+}
+void WMTrigger::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMTrigger(";
+  out << "resourcePlanName=" << to_string(resourcePlanName);
+  out << ", " << "poolName=" << to_string(poolName);
+  out << ", " << "triggerExpression="; (__isset.triggerExpression ? (out << to_string(triggerExpression)) : (out << "<null>"));
+  out << ", " << "actionExpression="; (__isset.actionExpression ? (out << to_string(actionExpression)) : (out << "<null>"));
+  out << ")";
+}
+
+
+WMMapping::~WMMapping() throw() {
+}
+
+
+void WMMapping::__set_resourcePlanName(const std::string& val) {
+  this->resourcePlanName = val;
+}
+
+void WMMapping::__set_entityType(const std::string& val) {
+  this->entityType = val;
+}
+
+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_ordering(const int32_t val) {
+  this->ordering = val;
+__isset.ordering = true;
+}
+
+uint32_t WMMapping::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_resourcePlanName = false;
+  bool isset_entityType = false;
+  bool isset_entityName = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->resourcePlanName);
+          isset_resourcePlanName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->entityType);
+          isset_entityType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->entityName);
+          isset_entityName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->poolName);
+          this->__isset.poolName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->ordering);
+          this->__isset.ordering = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_resourcePlanName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_entityType)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_entityName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t WMMapping::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("WMMapping");
+
+  xfer += oprot->writeFieldBegin("resourcePlanName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->resourcePlanName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("entityType", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->entityType);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("entityName", ::apache::thrift::protocol::T_STRING, 3);
+  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);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.ordering) {
+    xfer += oprot->writeFieldBegin("ordering", ::apache::thrift::protocol::T_I32, 5);
+    xfer += oprot->writeI32(this->ordering);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(WMMapping &a, WMMapping &b) {
+  using ::std::swap;
+  swap(a.resourcePlanName, b.resourcePlanName);
+  swap(a.entityType, b.entityType);
+  swap(a.entityName, b.entityName);
+  swap(a.poolName, b.poolName);
+  swap(a.ordering, b.ordering);
+  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) {
+  resourcePlanName = other870.resourcePlanName;
+  entityType = other870.entityType;
+  entityName = other870.entityName;
+  poolName = other870.poolName;
+  ordering = other870.ordering;
+  __isset = other870.__isset;
+  return *this;
+}
+void WMMapping::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "WMMapping(";
+  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 << ", " << "ordering="; (__isset.ordering ? (out << to_string(ordering)) : (out << "<null>"));
+  out << ")";
+}
+
+
 MetaException::~MetaException() throw() {
 }
 
@@ -20829,13 +21497,13 @@ void swap(MetaException &a, MetaException &b) {
   swap(a.__isset, b.__isset);
 }
 
-MetaException::MetaException(const MetaException& other863) : TException() {
-  message = other863.message;
-  __isset = other863.__isset;
+MetaException::MetaException(const MetaException& other871) : TException() {
+  message = other871.message;
+  __isset = other871.__isset;
 }
-MetaException& MetaException::operator=(const MetaException& other864) {
-  message = other864.message;
-  __isset = other864.__isset;
+MetaException& MetaException::operator=(const MetaException& other872) {
+  message = other872.message;
+  __isset = other872.__isset;
   return *this;
 }
 void MetaException::printTo(std::ostream& out) const {
@@ -20926,13 +21594,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownTableException::UnknownTableException(const UnknownTableException& other865) : TException() {
-  message = other865.message;
-  __isset = other865.__isset;
+UnknownTableException::UnknownTableException(const UnknownTableException& other873) : TException() {
+  message = other873.message;
+  __isset = other873.__isset;
 }
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other866) {
-  message = other866.message;
-  __isset = other866.__isset;
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other874) {
+  message = other874.message;
+  __isset = other874.__isset;
   return *this;
 }
 void UnknownTableException::printTo(std::ostream& out) const {
@@ -21023,13 +21691,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownDBException::UnknownDBException(const UnknownDBException& other867) : TException() {
-  message = other867.message;
-  __isset = other867.__isset;
+UnknownDBException::UnknownDBException(const UnknownDBException& other875) : TException() {
+  message = other875.message;
+  __isset = other875.__isset;
 }
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other868) {
-  message = other868.message;
-  __isset = other868.__isset;
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other876) {
+  message = other876.message;
+  __isset = other876.__isset;
   return *this;
 }
 void UnknownDBException::printTo(std::ostream& out) const {
@@ -21120,13 +21788,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other869) : TException() {
-  message = other869.message;
-  __isset = other869.__isset;
+AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other877) : TException() {
+  message = other877.message;
+  __isset = other877.__isset;
 }
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other870) {
-  message = other870.message;
-  __isset = other870.__isset;
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other878) {
+  message = other878.message;
+  __isset = other878.__isset;
   return *this;
 }
 void AlreadyExistsException::printTo(std::ostream& out) const {
@@ -21217,13 +21885,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other871) : TException() {
-  message = other871.message;
-  __isset = other871.__isset;
+InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other879) : TException() {
+  message = other879.message;
+  __isset = other879.__isset;
 }
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other872) {
-  message = other872.message;
-  __isset = other872.__isset;
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other880) {
+  message = other880.message;
+  __isset = other880.__isset;
   return *this;
 }
 void InvalidPartitionException::printTo(std::ostream& out) const {
@@ -21314,13 +21982,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other873) : TException() {
-  message = other873.message;
-  __isset = other873.__isset;
+UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other881) : TException() {
+  message = other881.message;
+  __isset = other881.__isset;
 }
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other874) {
-  message = other874.message;
-  __isset = other874.__isset;
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other882) {
+  message = other882.message;
+  __isset = other882.__isset;
   return *this;
 }
 void UnknownPartitionException::printTo(std::ostream& out) const {
@@ -21411,13 +22079,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other875) : TException() {
-  message = other875.message;
-  __isset = other875.__isset;
+InvalidObjectException::InvalidObjectException(const InvalidObjectException& other883) : TException() {
+  message = other883.message;
+  __isset = other883.__isset;
 }
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other876) {
-  message = other876.message;
-  __isset = other876.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other884) {
+  message = other884.message;
+  __isset = other884.__isset;
   return *this;
 }
 void InvalidObjectException::printTo(std::ostream& out) const {
@@ -21508,13 +22176,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other877) : TException() {
-  message = other877.message;
-  __isset = other877.__isset;
+NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other885) : TException() {
+  message = other885.message;
+  __isset = other885.__isset;
 }
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other878) {
-  message = other878.message;
-  __isset = other878.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other886) {
+  message = other886.message;
+  __isset = other886.__isset;
   return *this;
 }
 void NoSuchObjectException::printTo(std::ostream& out) const {
@@ -21605,13 +22273,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other879) : TException() {
-  message = other879.message;
-  __isset = other879.__isset;
+IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other887) : TException() {
+  message = other887.message;
+  __isset = other887.__isset;
 }
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other880) {
-  message = other880.message;
-  __isset = other880.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other888) {
+  message = other888.message;
+  __isset = other888.__isset;
   return *this;
 }
 void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@ -21702,13 +22370,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other881) : TException() {
-  message = other881.message;
-  __isset = other881.__isset;
+InvalidOperationException::InvalidOperationException(const InvalidOperationException& other889) : TException() {
+  message = other889.message;
+  __isset = other889.__isset;
 }
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other882) {
-  message = other882.message;
-  __isset = other882.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other890) {
+  message = other890.message;
+  __isset = other890.__isset;
   return *this;
 }
 void InvalidOperationException::printTo(std::ostream& out) const {
@@ -21799,13 +22467,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) {
   swap(a.__isset, b.__isset);
 }
 
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other883) : TException() {
-  message = other883.message;
-  __isset = other883.__isset;
+ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other891) : TException() {
+  message = other891.message;
+  __isset = other891.__isset;
 }
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other884) {
-  message = other884.message;
-  __isset = other884.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other892) {
+  message = other892.message;
+  __isset = other892.__isset;
   return *this;
 }
 void ConfigValSecurityException::printTo(std::ostream& out) const {
@@ -21896,13 +22564,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidInputException::InvalidInputException(const InvalidInputException& other885) : TException() {
-  message = other885.message;
-  __isset = other885.__isset;
+InvalidInputException::InvalidInputException(const InvalidInputException& other893) : TException() {
+  message = other893.message;
+  __isset = other893.__isset;
 }
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other886) {
-  message = other886.message;
-  __isset = other886.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other894) {
+  message = other894.message;
+  __isset = other894.__isset;
   return *this;
 }
 void InvalidInputException::printTo(std::ostream& out) const {
@@ -21993,13 +22661,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other887) : TException() {
-  message = other887.message;
-  __isset = other887.__isset;
+NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other895) : TException() {
+  message = other895.message;
+  __isset = other895.__isset;
 }
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other888) {
-  message = other888.message;
-  __isset = other888.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other896) {
+  message = other896.message;
+  __isset = other896.__isset;
   return *this;
 }
 void NoSuchTxnException::printTo(std::ostream& out) const {
@@ -22090,13 +22758,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other889) : TException() {
-  message = other889.message;
-  __isset = other889.__isset;
+TxnAbortedException::TxnAbortedException(const TxnAbortedException& other897) : TException() {
+  message = other897.message;
+  __isset = other897.__isset;
 }
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other890) {
-  message = other890.message;
-  __isset = other890.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other898) {
+  message = other898.message;
+  __isset = other898.__isset;
   return *this;
 }
 void TxnAbortedException::printTo(std::ostream& out) const {
@@ -22187,13 +22855,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnOpenException::TxnOpenException(const TxnOpenException& other891) : TException() {
-  message = other891.message;
-  __isset = other891.__isset;
+TxnOpenException::TxnOpenException(const TxnOpenException& other899) : TException() {
+  message = other899.message;
+  __isset = other899.__isset;
 }
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other892) {
-  message = other892.message;
-  __isset = other892.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other900) {
+  message = other900.message;
+  __isset = other900.__isset;
   return *this;
 }
 void TxnOpenException::printTo(std::ostream& out) const {
@@ -22284,13 +22952,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other893) : TException() {
-  message = other893.message;
-  __isset = other893.__isset;
+NoSuchLockException::NoSuchLockException(const NoSuchLockException& other901) : TException() {
+  message = other901.message;
+  __isset = other901.__isset;
 }
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other894) {
-  message = other894.message;
-  __isset = other894.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other902) {
+  message = other902.message;
+  __isset = other902.__isset;
   return *this;
 }
 void NoSuchLockException::printTo(std::ostream& out) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/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 fd9014d..9c883ca 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
@@ -438,6 +438,14 @@ class CmRecycleResponse;
 
 class TableMeta;
 
+class WMResourcePlan;
+
+class WMPool;
+
+class WMTrigger;
+
+class WMMapping;
+
 class MetaException;
 
 class UnknownTableException;
@@ -8441,6 +8449,286 @@ inline std::ostream& operator<<(std::ostream& out, const TableMeta& obj)
   return out;
 }
 
+typedef struct _WMResourcePlan__isset {
+  _WMResourcePlan__isset() : status(false), queryParallelism(false) {}
+  bool status :1;
+  bool queryParallelism :1;
+} _WMResourcePlan__isset;
+
+class WMResourcePlan {
+ public:
+
+  WMResourcePlan(const WMResourcePlan&);
+  WMResourcePlan& operator=(const WMResourcePlan&);
+  WMResourcePlan() : name(), status(), queryParallelism(0) {
+  }
+
+  virtual ~WMResourcePlan() throw();
+  std::string name;
+  std::string status;
+  int32_t queryParallelism;
+
+  _WMResourcePlan__isset __isset;
+
+  void __set_name(const std::string& val);
+
+  void __set_status(const std::string& val);
+
+  void __set_queryParallelism(const int32_t val);
+
+  bool operator == (const WMResourcePlan & rhs) const
+  {
+    if (!(name == rhs.name))
+      return false;
+    if (__isset.status != rhs.__isset.status)
+      return false;
+    else if (__isset.status && !(status == rhs.status))
+      return false;
+    if (__isset.queryParallelism != rhs.__isset.queryParallelism)
+      return false;
+    else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism))
+      return false;
+    return true;
+  }
+  bool operator != (const WMResourcePlan &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMResourcePlan & ) 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(WMResourcePlan &a, WMResourcePlan &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMResourcePlan& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMPool__isset {
+  _WMPool__isset() : parentPoolName(false), allocFraction(false), queryParallelism(false), schedulingPolicy(false) {}
+  bool parentPoolName :1;
+  bool allocFraction :1;
+  bool queryParallelism :1;
+  bool schedulingPolicy :1;
+} _WMPool__isset;
+
+class WMPool {
+ public:
+
+  WMPool(const WMPool&);
+  WMPool& operator=(const WMPool&);
+  WMPool() : resourcePlanName(), poolName(), parentPoolName(), allocFraction(0), queryParallelism(0), schedulingPolicy() {
+  }
+
+  virtual ~WMPool() throw();
+  std::string resourcePlanName;
+  std::string poolName;
+  std::string parentPoolName;
+  double allocFraction;
+  int32_t queryParallelism;
+  std::string schedulingPolicy;
+
+  _WMPool__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  void __set_poolName(const std::string& val);
+
+  void __set_parentPoolName(const std::string& val);
+
+  void __set_allocFraction(const double val);
+
+  void __set_queryParallelism(const int32_t val);
+
+  void __set_schedulingPolicy(const std::string& val);
+
+  bool operator == (const WMPool & rhs) const
+  {
+    if (!(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    if (!(poolName == rhs.poolName))
+      return false;
+    if (__isset.parentPoolName != rhs.__isset.parentPoolName)
+      return false;
+    else if (__isset.parentPoolName && !(parentPoolName == rhs.parentPoolName))
+      return false;
+    if (__isset.allocFraction != rhs.__isset.allocFraction)
+      return false;
+    else if (__isset.allocFraction && !(allocFraction == rhs.allocFraction))
+      return false;
+    if (__isset.queryParallelism != rhs.__isset.queryParallelism)
+      return false;
+    else if (__isset.queryParallelism && !(queryParallelism == rhs.queryParallelism))
+      return false;
+    if (__isset.schedulingPolicy != rhs.__isset.schedulingPolicy)
+      return false;
+    else if (__isset.schedulingPolicy && !(schedulingPolicy == rhs.schedulingPolicy))
+      return false;
+    return true;
+  }
+  bool operator != (const WMPool &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMPool & ) 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(WMPool &a, WMPool &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMPool& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMTrigger__isset {
+  _WMTrigger__isset() : triggerExpression(false), actionExpression(false) {}
+  bool triggerExpression :1;
+  bool actionExpression :1;
+} _WMTrigger__isset;
+
+class WMTrigger {
+ public:
+
+  WMTrigger(const WMTrigger&);
+  WMTrigger& operator=(const WMTrigger&);
+  WMTrigger() : resourcePlanName(), poolName(), triggerExpression(), actionExpression() {
+  }
+
+  virtual ~WMTrigger() throw();
+  std::string resourcePlanName;
+  std::string poolName;
+  std::string triggerExpression;
+  std::string actionExpression;
+
+  _WMTrigger__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  void __set_poolName(const std::string& val);
+
+  void __set_triggerExpression(const std::string& val);
+
+  void __set_actionExpression(const std::string& val);
+
+  bool operator == (const WMTrigger & rhs) const
+  {
+    if (!(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    if (!(poolName == rhs.poolName))
+      return false;
+    if (__isset.triggerExpression != rhs.__isset.triggerExpression)
+      return false;
+    else if (__isset.triggerExpression && !(triggerExpression == rhs.triggerExpression))
+      return false;
+    if (__isset.actionExpression != rhs.__isset.actionExpression)
+      return false;
+    else if (__isset.actionExpression && !(actionExpression == rhs.actionExpression))
+      return false;
+    return true;
+  }
+  bool operator != (const WMTrigger &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMTrigger & ) 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(WMTrigger &a, WMTrigger &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMTrigger& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _WMMapping__isset {
+  _WMMapping__isset() : poolName(false), ordering(false) {}
+  bool poolName :1;
+  bool ordering :1;
+} _WMMapping__isset;
+
+class WMMapping {
+ public:
+
+  WMMapping(const WMMapping&);
+  WMMapping& operator=(const WMMapping&);
+  WMMapping() : resourcePlanName(), entityType(), entityName(), poolName(), ordering(0) {
+  }
+
+  virtual ~WMMapping() throw();
+  std::string resourcePlanName;
+  std::string entityType;
+  std::string entityName;
+  std::string poolName;
+  int32_t ordering;
+
+  _WMMapping__isset __isset;
+
+  void __set_resourcePlanName(const std::string& val);
+
+  void __set_entityType(const std::string& val);
+
+  void __set_entityName(const std::string& val);
+
+  void __set_poolName(const std::string& val);
+
+  void __set_ordering(const int32_t val);
+
+  bool operator == (const WMMapping & rhs) const
+  {
+    if (!(resourcePlanName == rhs.resourcePlanName))
+      return false;
+    if (!(entityType == rhs.entityType))
+      return false;
+    if (!(entityName == rhs.entityName))
+      return false;
+    if (__isset.poolName != rhs.__isset.poolName)
+      return false;
+    else if (__isset.poolName && !(poolName == rhs.poolName))
+      return false;
+    if (__isset.ordering != rhs.__isset.ordering)
+      return false;
+    else if (__isset.ordering && !(ordering == rhs.ordering))
+      return false;
+    return true;
+  }
+  bool operator != (const WMMapping &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const WMMapping & ) 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(WMMapping &a, WMMapping &b);
+
+inline std::ostream& operator<<(std::ostream& out, const WMMapping& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message :1;

http://git-wip-us.apache.org/repos/asf/hive/blob/32b7abac/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java
new file mode 100644
index 0000000..cbf4f38
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/WMMapping.java
@@ -0,0 +1,804 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class WMMapping implements org.apache.thrift.TBase<WMMapping, WMMapping._Fields>, java.io.Serializable, Cloneable, Comparable<WMMapping> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("WMMapping");
+
+  private static final org.apache.thrift.protocol.TField RESOURCE_PLAN_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("resourcePlanName", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField ENTITY_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("entityType", org.apache.thrift.protocol.TType.STRING, (short)2);
+  private static final org.apache.thrift.protocol.TField ENTITY_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("entityName", org.apache.thrift.protocol.TType.STRING, (short)3);
+  private static final org.apache.thrift.protocol.TField POOL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("poolName", org.apache.thrift.protocol.TType.STRING, (short)4);
+  private static final org.apache.thrift.protocol.TField ORDERING_FIELD_DESC = new org.apache.thrift.protocol.TField("ordering", org.apache.thrift.protocol.TType.I32, (short)5);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new WMMappingStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new WMMappingTupleSchemeFactory());
+  }
+
+  private String resourcePlanName; // required
+  private String entityType; // required
+  private String entityName; // required
+  private String poolName; // optional
+  private int ordering; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    RESOURCE_PLAN_NAME((short)1, "resourcePlanName"),
+    ENTITY_TYPE((short)2, "entityType"),
+    ENTITY_NAME((short)3, "entityName"),
+    POOL_NAME((short)4, "poolName"),
+    ORDERING((short)5, "ordering");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // RESOURCE_PLAN_NAME
+          return RESOURCE_PLAN_NAME;
+        case 2: // ENTITY_TYPE
+          return ENTITY_TYPE;
+        case 3: // ENTITY_NAME
+          return ENTITY_NAME;
+        case 4: // POOL_NAME
+          return POOL_NAME;
+        case 5: // ORDERING
+          return ORDERING;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __ORDERING_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  private static final _Fields optionals[] = {_Fields.POOL_NAME,_Fields.ORDERING};
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.RESOURCE_PLAN_NAME, new org.apache.thrift.meta_data.FieldMetaData("resourcePlanName", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.ENTITY_TYPE, new org.apache.thrift.meta_data.FieldMetaData("entityType", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.ENTITY_NAME, new org.apache.thrift.meta_data.FieldMetaData("entityName", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.POOL_NAME, new org.apache.thrift.meta_data.FieldMetaData("poolName", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.ORDERING, new org.apache.thrift.meta_data.FieldMetaData("ordering", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(WMMapping.class, metaDataMap);
+  }
+
+  public WMMapping() {
+  }
+
+  public WMMapping(
+    String resourcePlanName,
+    String entityType,
+    String entityName)
+  {
+    this();
+    this.resourcePlanName = resourcePlanName;
+    this.entityType = entityType;
+    this.entityName = entityName;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public WMMapping(WMMapping other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetResourcePlanName()) {
+      this.resourcePlanName = other.resourcePlanName;
+    }
+    if (other.isSetEntityType()) {
+      this.entityType = other.entityType;
+    }
+    if (other.isSetEntityName()) {
+      this.entityName = other.entityName;
+    }
+    if (other.isSetPoolName()) {
+      this.poolName = other.poolName;
+    }
+    this.ordering = other.ordering;
+  }
+
+  public WMMapping deepCopy() {
+    return new WMMapping(this);
+  }
+
+  @Override
+  public void clear() {
+    this.resourcePlanName = null;
+    this.entityType = null;
+    this.entityName = null;
+    this.poolName = null;
+    setOrderingIsSet(false);
+    this.ordering = 0;
+  }
+
+  public String getResourcePlanName() {
+    return this.resourcePlanName;
+  }
+
+  public void setResourcePlanName(String resourcePlanName) {
+    this.resourcePlanName = resourcePlanName;
+  }
+
+  public void unsetResourcePlanName() {
+    this.resourcePlanName = null;
+  }
+
+  /** Returns true if field resourcePlanName is set (has been assigned a value) and false otherwise */
+  public boolean isSetResourcePlanName() {
+    return this.resourcePlanName != null;
+  }
+
+  public void setResourcePlanNameIsSet(boolean value) {
+    if (!value) {
+      this.resourcePlanName = null;
+    }
+  }
+
+  public String getEntityType() {
+    return this.entityType;
+  }
+
+  public void setEntityType(String entityType) {
+    this.entityType = entityType;
+  }
+
+  public void unsetEntityType() {
+    this.entityType = null;
+  }
+
+  /** Returns true if field entityType is set (has been assigned a value) and false otherwise */
+  public boolean isSetEntityType() {
+    return this.entityType != null;
+  }
+
+  public void setEntityTypeIsSet(boolean value) {
+    if (!value) {
+      this.entityType = null;
+    }
+  }
+
+  public String getEntityName() {
+    return this.entityName;
+  }
+
+  public void setEntityName(String entityName) {
+    this.entityName = entityName;
+  }
+
+  public void unsetEntityName() {
+    this.entityName = null;
+  }
+
+  /** Returns true if field entityName is set (has been assigned a value) and false otherwise */
+  public boolean isSetEntityName() {
+    return this.entityName != null;
+  }
+
+  public void setEntityNameIsSet(boolean value) {
+    if (!value) {
+      this.entityName = null;
+    }
+  }
+
+  public String getPoolName() {
+    return this.poolName;
+  }
+
+  public void setPoolName(String poolName) {
+    this.poolName = poolName;
+  }
+
+  public void unsetPoolName() {
+    this.poolName = null;
+  }
+
+  /** Returns true if field poolName is set (has been assigned a value) and false otherwise */
+  public boolean isSetPoolName() {
+    return this.poolName != null;
+  }
+
+  public void setPoolNameIsSet(boolean value) {
+    if (!value) {
+      this.poolName = null;
+    }
+  }
+
+  public int getOrdering() {
+    return this.ordering;
+  }
+
+  public void setOrdering(int ordering) {
+    this.ordering = ordering;
+    setOrderingIsSet(true);
+  }
+
+  public void unsetOrdering() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ORDERING_ISSET_ID);
+  }
+
+  /** Returns true if field ordering is set (has been assigned a value) and false otherwise */
+  public boolean isSetOrdering() {
+    return EncodingUtils.testBit(__isset_bitfield, __ORDERING_ISSET_ID);
+  }
+
+  public void setOrderingIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ORDERING_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case RESOURCE_PLAN_NAME:
+      if (value == null) {
+        unsetResourcePlanName();
+      } else {
+        setResourcePlanName((String)value);
+      }
+      break;
+
+    case ENTITY_TYPE:
+      if (value == null) {
+        unsetEntityType();
+      } else {
+        setEntityType((String)value);
+      }
+      break;
+
+    case ENTITY_NAME:
+      if (value == null) {
+        unsetEntityName();
+      } else {
+        setEntityName((String)value);
+      }
+      break;
+
+    case POOL_NAME:
+      if (value == null) {
+        unsetPoolName();
+      } else {
+        setPoolName((String)value);
+      }
+      break;
+
+    case ORDERING:
+      if (value == null) {
+        unsetOrdering();
+      } else {
+        setOrdering((Integer)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case RESOURCE_PLAN_NAME:
+      return getResourcePlanName();
+
+    case ENTITY_TYPE:
+      return getEntityType();
+
+    case ENTITY_NAME:
+      return getEntityName();
+
+    case POOL_NAME:
+      return getPoolName();
+
+    case ORDERING:
+      return getOrdering();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case RESOURCE_PLAN_NAME:
+      return isSetResourcePlanName();
+    case ENTITY_TYPE:
+      return isSetEntityType();
+    case ENTITY_NAME:
+      return isSetEntityName();
+    case POOL_NAME:
+      return isSetPoolName();
+    case ORDERING:
+      return isSetOrdering();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof WMMapping)
+      return this.equals((WMMapping)that);
+    return false;
+  }
+
+  public boolean equals(WMMapping that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_resourcePlanName = true && this.isSetResourcePlanName();
+    boolean that_present_resourcePlanName = true && that.isSetResourcePlanName();
+    if (this_present_resourcePlanName || that_present_resourcePlanName) {
+      if (!(this_present_resourcePlanName && that_present_resourcePlanName))
+        return false;
+      if (!this.resourcePlanName.equals(that.resourcePlanName))
+        return false;
+    }
+
+    boolean this_present_entityType = true && this.isSetEntityType();
+    boolean that_present_entityType = true && that.isSetEntityType();
+    if (this_present_entityType || that_present_entityType) {
+      if (!(this_present_entityType && that_present_entityType))
+        return false;
+      if (!this.entityType.equals(that.entityType))
+        return false;
+    }
+
+    boolean this_present_entityName = true && this.isSetEntityName();
+    boolean that_present_entityName = true && that.isSetEntityName();
+    if (this_present_entityName || that_present_entityName) {
+      if (!(this_present_entityName && that_present_entityName))
+        return false;
+      if (!this.entityName.equals(that.entityName))
+        return false;
+    }
+
+    boolean this_present_poolName = true && this.isSetPoolName();
+    boolean that_present_poolName = true && that.isSetPoolName();
+    if (this_present_poolName || that_present_poolName) {
+      if (!(this_present_poolName && that_present_poolName))
+        return false;
+      if (!this.poolName.equals(that.poolName))
+        return false;
+    }
+
+    boolean this_present_ordering = true && this.isSetOrdering();
+    boolean that_present_ordering = true && that.isSetOrdering();
+    if (this_present_ordering || that_present_ordering) {
+      if (!(this_present_ordering && that_present_ordering))
+        return false;
+      if (this.ordering != that.ordering)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_resourcePlanName = true && (isSetResourcePlanName());
+    list.add(present_resourcePlanName);
+    if (present_resourcePlanName)
+      list.add(resourcePlanName);
+
+    boolean present_entityType = true && (isSetEntityType());
+    list.add(present_entityType);
+    if (present_entityType)
+      list.add(entityType);
+
+    boolean present_entityName = true && (isSetEntityName());
+    list.add(present_entityName);
+    if (present_entityName)
+      list.add(entityName);
+
+    boolean present_poolName = true && (isSetPoolName());
+    list.add(present_poolName);
+    if (present_poolName)
+      list.add(poolName);
+
+    boolean present_ordering = true && (isSetOrdering());
+    list.add(present_ordering);
+    if (present_ordering)
+      list.add(ordering);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(WMMapping other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetResourcePlanName()).compareTo(other.isSetResourcePlanName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetResourcePlanName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resourcePlanName, other.resourcePlanName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetEntityType()).compareTo(other.isSetEntityType());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEntityType()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.entityType, other.entityType);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetEntityName()).compareTo(other.isSetEntityName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetEntityName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.entityName, other.entityName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetPoolName()).compareTo(other.isSetPoolName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetPoolName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.poolName, other.poolName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetOrdering()).compareTo(other.isSetOrdering());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetOrdering()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ordering, other.ordering);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("WMMapping(");
+    boolean first = true;
+
+    sb.append("resourcePlanName:");
+    if (this.resourcePlanName == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.resourcePlanName);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("entityType:");
+    if (this.entityType == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.entityType);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("entityName:");
+    if (this.entityName == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.entityName);
+    }
+    first = false;
+    if (isSetPoolName()) {
+      if (!first) sb.append(", ");
+      sb.append("poolName:");
+      if (this.poolName == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.poolName);
+      }
+      first = false;
+    }
+    if (isSetOrdering()) {
+      if (!first) sb.append(", ");
+      sb.append("ordering:");
+      sb.append(this.ordering);
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetResourcePlanName()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'resourcePlanName' is unset! Struct:" + toString());
+    }
+
+    if (!isSetEntityType()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'entityType' is unset! Struct:" + toString());
+    }
+
+    if (!isSetEntityName()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'entityName' is unset! Struct:" + toString());
+    }
+
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class WMMappingStandardSchemeFactory implements SchemeFactory {
+    public WMMappingStandardScheme getScheme() {
+      return new WMMappingStandardScheme();
+    }
+  }
+
+  private static class WMMappingStandardScheme extends StandardScheme<WMMapping> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, WMMapping struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // RESOURCE_PLAN_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.resourcePlanName = iprot.readString();
+              struct.setResourcePlanNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // ENTITY_TYPE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.entityType = iprot.readString();
+              struct.setEntityTypeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // ENTITY_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.entityName = iprot.readString();
+              struct.setEntityNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // POOL_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.poolName = iprot.readString();
+              struct.setPoolNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 5: // ORDERING
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.ordering = iprot.readI32();
+              struct.setOrderingIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, WMMapping struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.resourcePlanName != null) {
+        oprot.writeFieldBegin(RESOURCE_PLAN_NAME_FIELD_DESC);
+        oprot.writeString(struct.resourcePlanName);
+        oprot.writeFieldEnd();
+      }
+      if (struct.entityType != null) {
+        oprot.writeFieldBegin(ENTITY_TYPE_FIELD_DESC);
+        oprot.writeString(struct.entityType);
+        oprot.writeFieldEnd();
+      }
+      if (struct.entityName != null) {
+        oprot.writeFieldBegin(ENTITY_NAME_FIELD_DESC);
+        oprot.writeString(struct.entityName);
+        oprot.writeFieldEnd();
+      }
+      if (struct.poolName != null) {
+        if (struct.isSetPoolName()) {
+          oprot.writeFieldBegin(POOL_NAME_FIELD_DESC);
+          oprot.writeString(struct.poolName);
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.isSetOrdering()) {
+        oprot.writeFieldBegin(ORDERING_FIELD_DESC);
+        oprot.writeI32(struct.ordering);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class WMMappingTupleSchemeFactory implements SchemeFactory {
+    public WMMappingTupleScheme getScheme() {
+      return new WMMappingTupleScheme();
+    }
+  }
+
+  private static class WMMappingTupleScheme extends TupleScheme<WMMapping> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeString(struct.resourcePlanName);
+      oprot.writeString(struct.entityType);
+      oprot.writeString(struct.entityName);
+      BitSet optionals = new BitSet();
+      if (struct.isSetPoolName()) {
+        optionals.set(0);
+      }
+      if (struct.isSetOrdering()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetPoolName()) {
+        oprot.writeString(struct.poolName);
+      }
+      if (struct.isSetOrdering()) {
+        oprot.writeI32(struct.ordering);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, WMMapping struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.resourcePlanName = iprot.readString();
+      struct.setResourcePlanNameIsSet(true);
+      struct.entityType = iprot.readString();
+      struct.setEntityTypeIsSet(true);
+      struct.entityName = iprot.readString();
+      struct.setEntityNameIsSet(true);
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.poolName = iprot.readString();
+        struct.setPoolNameIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.ordering = iprot.readI32();
+        struct.setOrderingIsSet(true);
+      }
+    }
+  }
+
+}
+


Mime
View raw message