hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ser...@apache.org
Subject [48/50] [abbrv] hive git commit: HIVE-14671 : merge master into hive-14535 (exim conflicts merge 1) (Sergey Shelukhin)
Date Tue, 15 Nov 2016 20:21:20 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/b3914c37/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 380257c,974ddb5..17f911f
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@@ -18268,457 -18277,108 +18276,1044 @@@ HeartbeatWriteIdResult::~HeartbeatWrite
  }
  
  
 -void GetTablesResult::__set_tables(const std::vector<Table> & val) {
 -  this->tables = val;
 -}
 +uint32_t HeartbeatWriteIdResult::read(::apache::thrift::protocol::TProtocol* iprot) {
  
 -uint32_t GetTablesResult::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 HeartbeatWriteIdResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
 +  uint32_t xfer = 0;
 +  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
 +  xfer += oprot->writeStructBegin("HeartbeatWriteIdResult");
 +
 +  xfer += oprot->writeFieldStop();
 +  xfer += oprot->writeStructEnd();
 +  return xfer;
 +}
 +
 +void swap(HeartbeatWriteIdResult &a, HeartbeatWriteIdResult &b) {
 +  using ::std::swap;
 +  (void) a;
 +  (void) b;
 +}
 +
 +HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other749) {
 +  (void) other749;
 +}
 +HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other750) {
 +  (void) other750;
 +  return *this;
 +}
 +void HeartbeatWriteIdResult::printTo(std::ostream& out) const {
 +  using ::apache::thrift::to_string;
 +  out << "HeartbeatWriteIdResult(";
 +  out << ")";
 +}
 +
 +
 +GetValidWriteIdsRequest::~GetValidWriteIdsRequest() throw() {
 +}
 +
 +
 +void GetValidWriteIdsRequest::__set_dbName(const std::string& val) {
 +  this->dbName = val;
 +}
 +
 +void GetValidWriteIdsRequest::__set_tblName(const std::string& val) {
 +  this->tblName = val;
 +}
 +
 +uint32_t GetValidWriteIdsRequest::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_dbName = false;
 +  bool isset_tblName = 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->dbName);
 +          isset_dbName = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      case 2:
 +        if (ftype == ::apache::thrift::protocol::T_STRING) {
 +          xfer += iprot->readString(this->tblName);
 +          isset_tblName = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      default:
 +        xfer += iprot->skip(ftype);
 +        break;
 +    }
 +    xfer += iprot->readFieldEnd();
 +  }
 +
 +  xfer += iprot->readStructEnd();
 +
 +  if (!isset_dbName)
 +    throw TProtocolException(TProtocolException::INVALID_DATA);
 +  if (!isset_tblName)
 +    throw TProtocolException(TProtocolException::INVALID_DATA);
 +  return xfer;
 +}
 +
 +uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
 +  uint32_t xfer = 0;
 +  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
 +  xfer += oprot->writeStructBegin("GetValidWriteIdsRequest");
 +
 +  xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
 +  xfer += oprot->writeString(this->dbName);
 +  xfer += oprot->writeFieldEnd();
 +
 +  xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
 +  xfer += oprot->writeString(this->tblName);
 +  xfer += oprot->writeFieldEnd();
 +
 +  xfer += oprot->writeFieldStop();
 +  xfer += oprot->writeStructEnd();
 +  return xfer;
 +}
 +
 +void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) {
 +  using ::std::swap;
 +  swap(a.dbName, b.dbName);
 +  swap(a.tblName, b.tblName);
 +}
 +
 +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other751) {
 +  dbName = other751.dbName;
 +  tblName = other751.tblName;
 +}
 +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other752) {
 +  dbName = other752.dbName;
 +  tblName = other752.tblName;
 +  return *this;
 +}
 +void GetValidWriteIdsRequest::printTo(std::ostream& out) const {
 +  using ::apache::thrift::to_string;
 +  out << "GetValidWriteIdsRequest(";
 +  out << "dbName=" << to_string(dbName);
 +  out << ", " << "tblName=" << to_string(tblName);
 +  out << ")";
 +}
 +
 +
 +GetValidWriteIdsResult::~GetValidWriteIdsResult() throw() {
 +}
 +
 +
 +void GetValidWriteIdsResult::__set_lowWatermarkId(const int64_t val) {
 +  this->lowWatermarkId = val;
 +}
 +
 +void GetValidWriteIdsResult::__set_highWatermarkId(const int64_t val) {
 +  this->highWatermarkId = val;
 +}
 +
 +void GetValidWriteIdsResult::__set_areIdsValid(const bool val) {
 +  this->areIdsValid = val;
 +__isset.areIdsValid = true;
 +}
 +
 +void GetValidWriteIdsResult::__set_ids(const std::vector<int64_t> & val) {
 +  this->ids = val;
 +__isset.ids = true;
 +}
 +
 +uint32_t GetValidWriteIdsResult::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_lowWatermarkId = false;
 +  bool isset_highWatermarkId = 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_I64) {
 +          xfer += iprot->readI64(this->lowWatermarkId);
 +          isset_lowWatermarkId = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      case 2:
 +        if (ftype == ::apache::thrift::protocol::T_I64) {
 +          xfer += iprot->readI64(this->highWatermarkId);
 +          isset_highWatermarkId = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      case 3:
 +        if (ftype == ::apache::thrift::protocol::T_BOOL) {
 +          xfer += iprot->readBool(this->areIdsValid);
 +          this->__isset.areIdsValid = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      case 4:
 +        if (ftype == ::apache::thrift::protocol::T_LIST) {
 +          {
 +            this->ids.clear();
 +            uint32_t _size753;
 +            ::apache::thrift::protocol::TType _etype756;
 +            xfer += iprot->readListBegin(_etype756, _size753);
 +            this->ids.resize(_size753);
 +            uint32_t _i757;
 +            for (_i757 = 0; _i757 < _size753; ++_i757)
 +            {
 +              xfer += iprot->readI64(this->ids[_i757]);
 +            }
 +            xfer += iprot->readListEnd();
 +          }
 +          this->__isset.ids = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      default:
 +        xfer += iprot->skip(ftype);
 +        break;
 +    }
 +    xfer += iprot->readFieldEnd();
 +  }
 +
 +  xfer += iprot->readStructEnd();
 +
 +  if (!isset_lowWatermarkId)
 +    throw TProtocolException(TProtocolException::INVALID_DATA);
 +  if (!isset_highWatermarkId)
 +    throw TProtocolException(TProtocolException::INVALID_DATA);
 +  return xfer;
 +}
 +
 +uint32_t GetValidWriteIdsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
 +  uint32_t xfer = 0;
 +  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
 +  xfer += oprot->writeStructBegin("GetValidWriteIdsResult");
 +
 +  xfer += oprot->writeFieldBegin("lowWatermarkId", ::apache::thrift::protocol::T_I64, 1);
 +  xfer += oprot->writeI64(this->lowWatermarkId);
 +  xfer += oprot->writeFieldEnd();
 +
 +  xfer += oprot->writeFieldBegin("highWatermarkId", ::apache::thrift::protocol::T_I64, 2);
 +  xfer += oprot->writeI64(this->highWatermarkId);
 +  xfer += oprot->writeFieldEnd();
 +
 +  if (this->__isset.areIdsValid) {
 +    xfer += oprot->writeFieldBegin("areIdsValid", ::apache::thrift::protocol::T_BOOL, 3);
 +    xfer += oprot->writeBool(this->areIdsValid);
 +    xfer += oprot->writeFieldEnd();
 +  }
 +  if (this->__isset.ids) {
 +    xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_LIST, 4);
 +    {
 +      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->ids.size()));
 +      std::vector<int64_t> ::const_iterator _iter758;
 +      for (_iter758 = this->ids.begin(); _iter758 != this->ids.end(); ++_iter758)
 +      {
 +        xfer += oprot->writeI64((*_iter758));
 +      }
 +      xfer += oprot->writeListEnd();
 +    }
 +    xfer += oprot->writeFieldEnd();
 +  }
 +  xfer += oprot->writeFieldStop();
 +  xfer += oprot->writeStructEnd();
 +  return xfer;
 +}
 +
 +void swap(GetValidWriteIdsResult &a, GetValidWriteIdsResult &b) {
 +  using ::std::swap;
 +  swap(a.lowWatermarkId, b.lowWatermarkId);
 +  swap(a.highWatermarkId, b.highWatermarkId);
 +  swap(a.areIdsValid, b.areIdsValid);
 +  swap(a.ids, b.ids);
 +  swap(a.__isset, b.__isset);
 +}
 +
 +GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other759) {
 +  lowWatermarkId = other759.lowWatermarkId;
 +  highWatermarkId = other759.highWatermarkId;
 +  areIdsValid = other759.areIdsValid;
 +  ids = other759.ids;
 +  __isset = other759.__isset;
 +}
 +GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other760) {
 +  lowWatermarkId = other760.lowWatermarkId;
 +  highWatermarkId = other760.highWatermarkId;
 +  areIdsValid = other760.areIdsValid;
 +  ids = other760.ids;
 +  __isset = other760.__isset;
 +  return *this;
 +}
 +void GetValidWriteIdsResult::printTo(std::ostream& out) const {
 +  using ::apache::thrift::to_string;
 +  out << "GetValidWriteIdsResult(";
 +  out << "lowWatermarkId=" << to_string(lowWatermarkId);
 +  out << ", " << "highWatermarkId=" << to_string(highWatermarkId);
 +  out << ", " << "areIdsValid="; (__isset.areIdsValid ? (out << to_string(areIdsValid)) : (out << "<null>"));
 +  out << ", " << "ids="; (__isset.ids ? (out << to_string(ids)) : (out << "<null>"));
 +  out << ")";
 +}
 +
 +
 +GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() {
 +}
 +
 +
 +void GetAllFunctionsResponse::__set_functions(const std::vector<Function> & val) {
 +  this->functions = val;
 +__isset.functions = true;
 +}
 +
 +uint32_t GetAllFunctionsResponse::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_LIST) {
 +          {
 +            this->functions.clear();
 +            uint32_t _size761;
 +            ::apache::thrift::protocol::TType _etype764;
 +            xfer += iprot->readListBegin(_etype764, _size761);
 +            this->functions.resize(_size761);
 +            uint32_t _i765;
 +            for (_i765 = 0; _i765 < _size761; ++_i765)
 +            {
 +              xfer += this->functions[_i765].read(iprot);
 +            }
 +            xfer += iprot->readListEnd();
 +          }
 +          this->__isset.functions = true;
 +        } else {
 +          xfer += iprot->skip(ftype);
 +        }
 +        break;
 +      default:
 +        xfer += iprot->skip(ftype);
 +        break;
 +    }
 +    xfer += iprot->readFieldEnd();
 +  }
 +
 +  xfer += iprot->readStructEnd();
 +
 +  return xfer;
 +}
 +
 +uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
 +  uint32_t xfer = 0;
 +  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
 +  xfer += oprot->writeStructBegin("GetAllFunctionsResponse");
 +
 +  if (this->__isset.functions) {
 +    xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1);
 +    {
 +      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size()));
 +      std::vector<Function> ::const_iterator _iter766;
 +      for (_iter766 = this->functions.begin(); _iter766 != this->functions.end(); ++_iter766)
 +      {
 +        xfer += (*_iter766).write(oprot);
 +      }
 +      xfer += oprot->writeListEnd();
 +    }
 +    xfer += oprot->writeFieldEnd();
 +  }
 +  xfer += oprot->writeFieldStop();
 +  xfer += oprot->writeStructEnd();
 +  return xfer;
 +}
 +
 +void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
 +  using ::std::swap;
 +  swap(a.functions, b.functions);
 +  swap(a.__isset, b.__isset);
 +}
 +
 +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other767) {
 +  functions = other767.functions;
 +  __isset = other767.__isset;
 +}
 +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other768) {
 +  functions = other768.functions;
 +  __isset = other768.__isset;
 +  return *this;
 +}
 +void GetAllFunctionsResponse::printTo(std::ostream& out) const {
 +  using ::apache::thrift::to_string;
 +  out << "GetAllFunctionsResponse(";
 +  out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>"));
 +  out << ")";
 +}
 +
 +
++ClientCapabilities::~ClientCapabilities() throw() {
++}
++
++
++void ClientCapabilities::__set_values(const std::vector<ClientCapability::type> & val) {
++  this->values = val;
++}
++
++uint32_t ClientCapabilities::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_values = 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_LIST) {
++          {
++            this->values.clear();
++            uint32_t _size769;
++            ::apache::thrift::protocol::TType _etype772;
++            xfer += iprot->readListBegin(_etype772, _size769);
++            this->values.resize(_size769);
++            uint32_t _i773;
++            for (_i773 = 0; _i773 < _size769; ++_i773)
++            {
++              int32_t ecast774;
++              xfer += iprot->readI32(ecast774);
++              this->values[_i773] = (ClientCapability::type)ecast774;
++            }
++            xfer += iprot->readListEnd();
++          }
++          isset_values = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      default:
++        xfer += iprot->skip(ftype);
++        break;
++    }
++    xfer += iprot->readFieldEnd();
++  }
++
++  xfer += iprot->readStructEnd();
++
++  if (!isset_values)
++    throw TProtocolException(TProtocolException::INVALID_DATA);
++  return xfer;
++}
++
++uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) const {
++  uint32_t xfer = 0;
++  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
++  xfer += oprot->writeStructBegin("ClientCapabilities");
++
++  xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
++  {
++    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
++    std::vector<ClientCapability::type> ::const_iterator _iter775;
++    for (_iter775 = this->values.begin(); _iter775 != this->values.end(); ++_iter775)
++    {
++      xfer += oprot->writeI32((int32_t)(*_iter775));
++    }
++    xfer += oprot->writeListEnd();
++  }
++  xfer += oprot->writeFieldEnd();
++
++  xfer += oprot->writeFieldStop();
++  xfer += oprot->writeStructEnd();
++  return xfer;
++}
++
++void swap(ClientCapabilities &a, ClientCapabilities &b) {
++  using ::std::swap;
++  swap(a.values, b.values);
++}
++
++ClientCapabilities::ClientCapabilities(const ClientCapabilities& other776) {
++  values = other776.values;
++}
++ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other777) {
++  values = other777.values;
++  return *this;
++}
++void ClientCapabilities::printTo(std::ostream& out) const {
++  using ::apache::thrift::to_string;
++  out << "ClientCapabilities(";
++  out << "values=" << to_string(values);
++  out << ")";
++}
++
++
++GetTableRequest::~GetTableRequest() throw() {
++}
++
++
++void GetTableRequest::__set_dbName(const std::string& val) {
++  this->dbName = val;
++}
++
++void GetTableRequest::__set_tblName(const std::string& val) {
++  this->tblName = val;
++}
++
++void GetTableRequest::__set_capabilities(const ClientCapabilities& val) {
++  this->capabilities = val;
++__isset.capabilities = true;
++}
++
++uint32_t GetTableRequest::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_dbName = false;
++  bool isset_tblName = 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->dbName);
++          isset_dbName = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      case 2:
++        if (ftype == ::apache::thrift::protocol::T_STRING) {
++          xfer += iprot->readString(this->tblName);
++          isset_tblName = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      case 3:
++        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
++          xfer += this->capabilities.read(iprot);
++          this->__isset.capabilities = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      default:
++        xfer += iprot->skip(ftype);
++        break;
++    }
++    xfer += iprot->readFieldEnd();
++  }
++
++  xfer += iprot->readStructEnd();
++
++  if (!isset_dbName)
++    throw TProtocolException(TProtocolException::INVALID_DATA);
++  if (!isset_tblName)
++    throw TProtocolException(TProtocolException::INVALID_DATA);
++  return xfer;
++}
++
++uint32_t GetTableRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
++  uint32_t xfer = 0;
++  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
++  xfer += oprot->writeStructBegin("GetTableRequest");
++
++  xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
++  xfer += oprot->writeString(this->dbName);
++  xfer += oprot->writeFieldEnd();
++
++  xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
++  xfer += oprot->writeString(this->tblName);
++  xfer += oprot->writeFieldEnd();
++
++  if (this->__isset.capabilities) {
++    xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
++    xfer += this->capabilities.write(oprot);
++    xfer += oprot->writeFieldEnd();
++  }
++  xfer += oprot->writeFieldStop();
++  xfer += oprot->writeStructEnd();
++  return xfer;
++}
++
++void swap(GetTableRequest &a, GetTableRequest &b) {
++  using ::std::swap;
++  swap(a.dbName, b.dbName);
++  swap(a.tblName, b.tblName);
++  swap(a.capabilities, b.capabilities);
++  swap(a.__isset, b.__isset);
++}
++
++GetTableRequest::GetTableRequest(const GetTableRequest& other778) {
++  dbName = other778.dbName;
++  tblName = other778.tblName;
++  capabilities = other778.capabilities;
++  __isset = other778.__isset;
++}
++GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other779) {
++  dbName = other779.dbName;
++  tblName = other779.tblName;
++  capabilities = other779.capabilities;
++  __isset = other779.__isset;
++  return *this;
++}
++void GetTableRequest::printTo(std::ostream& out) const {
++  using ::apache::thrift::to_string;
++  out << "GetTableRequest(";
++  out << "dbName=" << to_string(dbName);
++  out << ", " << "tblName=" << to_string(tblName);
++  out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
++  out << ")";
++}
++
++
++GetTableResult::~GetTableResult() throw() {
++}
++
++
++void GetTableResult::__set_table(const Table& val) {
++  this->table = val;
++}
++
++uint32_t GetTableResult::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_table = false;
++
++  while (true)
++  {
++    xfer += iprot->readFieldBegin(fname, ftype, fid);
++    if (ftype == ::apache::thrift::protocol::T_STOP) {
++      break;
++    }
++    switch (fid)
++    {
++      case 1:
++        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
++          xfer += this->table.read(iprot);
++          isset_table = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      default:
++        xfer += iprot->skip(ftype);
++        break;
++    }
++    xfer += iprot->readFieldEnd();
++  }
++
++  xfer += iprot->readStructEnd();
++
++  if (!isset_table)
++    throw TProtocolException(TProtocolException::INVALID_DATA);
++  return xfer;
++}
++
++uint32_t GetTableResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
++  uint32_t xfer = 0;
++  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
++  xfer += oprot->writeStructBegin("GetTableResult");
++
++  xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRUCT, 1);
++  xfer += this->table.write(oprot);
++  xfer += oprot->writeFieldEnd();
++
++  xfer += oprot->writeFieldStop();
++  xfer += oprot->writeStructEnd();
++  return xfer;
++}
++
++void swap(GetTableResult &a, GetTableResult &b) {
++  using ::std::swap;
++  swap(a.table, b.table);
++}
++
++GetTableResult::GetTableResult(const GetTableResult& other780) {
++  table = other780.table;
++}
++GetTableResult& GetTableResult::operator=(const GetTableResult& other781) {
++  table = other781.table;
++  return *this;
++}
++void GetTableResult::printTo(std::ostream& out) const {
++  using ::apache::thrift::to_string;
++  out << "GetTableResult(";
++  out << "table=" << to_string(table);
++  out << ")";
++}
++
++
++GetTablesRequest::~GetTablesRequest() throw() {
++}
++
++
++void GetTablesRequest::__set_dbName(const std::string& val) {
++  this->dbName = val;
++}
++
++void GetTablesRequest::__set_tblNames(const std::vector<std::string> & val) {
++  this->tblNames = val;
++__isset.tblNames = true;
++}
++
++void GetTablesRequest::__set_capabilities(const ClientCapabilities& val) {
++  this->capabilities = val;
++__isset.capabilities = true;
++}
++
++uint32_t GetTablesRequest::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_dbName = 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->dbName);
++          isset_dbName = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      case 2:
++        if (ftype == ::apache::thrift::protocol::T_LIST) {
++          {
++            this->tblNames.clear();
++            uint32_t _size782;
++            ::apache::thrift::protocol::TType _etype785;
++            xfer += iprot->readListBegin(_etype785, _size782);
++            this->tblNames.resize(_size782);
++            uint32_t _i786;
++            for (_i786 = 0; _i786 < _size782; ++_i786)
++            {
++              xfer += iprot->readString(this->tblNames[_i786]);
++            }
++            xfer += iprot->readListEnd();
++          }
++          this->__isset.tblNames = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      case 3:
++        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
++          xfer += this->capabilities.read(iprot);
++          this->__isset.capabilities = true;
++        } else {
++          xfer += iprot->skip(ftype);
++        }
++        break;
++      default:
++        xfer += iprot->skip(ftype);
++        break;
++    }
++    xfer += iprot->readFieldEnd();
++  }
++
++  xfer += iprot->readStructEnd();
++
++  if (!isset_dbName)
++    throw TProtocolException(TProtocolException::INVALID_DATA);
++  return xfer;
++}
++
++uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
++  uint32_t xfer = 0;
++  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
++  xfer += oprot->writeStructBegin("GetTablesRequest");
++
++  xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
++  xfer += oprot->writeString(this->dbName);
++  xfer += oprot->writeFieldEnd();
++
++  if (this->__isset.tblNames) {
++    xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2);
++    {
++      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tblNames.size()));
++      std::vector<std::string> ::const_iterator _iter787;
++      for (_iter787 = this->tblNames.begin(); _iter787 != this->tblNames.end(); ++_iter787)
++      {
++        xfer += oprot->writeString((*_iter787));
++      }
++      xfer += oprot->writeListEnd();
++    }
++    xfer += oprot->writeFieldEnd();
++  }
++  if (this->__isset.capabilities) {
++    xfer += oprot->writeFieldBegin("capabilities", ::apache::thrift::protocol::T_STRUCT, 3);
++    xfer += this->capabilities.write(oprot);
++    xfer += oprot->writeFieldEnd();
++  }
++  xfer += oprot->writeFieldStop();
++  xfer += oprot->writeStructEnd();
++  return xfer;
++}
++
++void swap(GetTablesRequest &a, GetTablesRequest &b) {
++  using ::std::swap;
++  swap(a.dbName, b.dbName);
++  swap(a.tblNames, b.tblNames);
++  swap(a.capabilities, b.capabilities);
++  swap(a.__isset, b.__isset);
++}
++
++GetTablesRequest::GetTablesRequest(const GetTablesRequest& other788) {
++  dbName = other788.dbName;
++  tblNames = other788.tblNames;
++  capabilities = other788.capabilities;
++  __isset = other788.__isset;
++}
++GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other789) {
++  dbName = other789.dbName;
++  tblNames = other789.tblNames;
++  capabilities = other789.capabilities;
++  __isset = other789.__isset;
++  return *this;
++}
++void GetTablesRequest::printTo(std::ostream& out) const {
++  using ::apache::thrift::to_string;
++  out << "GetTablesRequest(";
++  out << "dbName=" << to_string(dbName);
++  out << ", " << "tblNames="; (__isset.tblNames ? (out << to_string(tblNames)) : (out << "<null>"));
++  out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
++  out << ")";
++}
++
++
++GetTablesResult::~GetTablesResult() throw() {
++}
++
++
++void GetTablesResult::__set_tables(const std::vector<Table> & val) {
++  this->tables = val;
++}
++
++uint32_t GetTablesResult::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_tables = 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_LIST) {
+           {
+             this->tables.clear();
 -            uint32_t _size768;
 -            ::apache::thrift::protocol::TType _etype771;
 -            xfer += iprot->readListBegin(_etype771, _size768);
 -            this->tables.resize(_size768);
 -            uint32_t _i772;
 -            for (_i772 = 0; _i772 < _size768; ++_i772)
++            uint32_t _size790;
++            ::apache::thrift::protocol::TType _etype793;
++            xfer += iprot->readListBegin(_etype793, _size790);
++            this->tables.resize(_size790);
++            uint32_t _i794;
++            for (_i794 = 0; _i794 < _size790; ++_i794)
+             {
 -              xfer += this->tables[_i772].read(iprot);
++              xfer += this->tables[_i794].read(iprot);
+             }
+             xfer += iprot->readListEnd();
+           }
+           isset_tables = true;
+         } else {
+           xfer += iprot->skip(ftype);
+         }
+         break;
+       default:
+         xfer += iprot->skip(ftype);
+         break;
+     }
+     xfer += iprot->readFieldEnd();
+   }
+ 
+   xfer += iprot->readStructEnd();
+ 
+   if (!isset_tables)
+     throw TProtocolException(TProtocolException::INVALID_DATA);
+   return xfer;
+ }
+ 
+ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+   uint32_t xfer = 0;
+   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+   xfer += oprot->writeStructBegin("GetTablesResult");
+ 
+   xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1);
+   {
+     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tables.size()));
 -    std::vector<Table> ::const_iterator _iter773;
 -    for (_iter773 = this->tables.begin(); _iter773 != this->tables.end(); ++_iter773)
++    std::vector<Table> ::const_iterator _iter795;
++    for (_iter795 = this->tables.begin(); _iter795 != this->tables.end(); ++_iter795)
+     {
 -      xfer += (*_iter773).write(oprot);
++      xfer += (*_iter795).write(oprot);
+     }
+     xfer += oprot->writeListEnd();
+   }
+   xfer += oprot->writeFieldEnd();
+ 
+   xfer += oprot->writeFieldStop();
+   xfer += oprot->writeStructEnd();
+   return xfer;
+ }
+ 
+ void swap(GetTablesResult &a, GetTablesResult &b) {
+   using ::std::swap;
+   swap(a.tables, b.tables);
+ }
+ 
 -GetTablesResult::GetTablesResult(const GetTablesResult& other774) {
 -  tables = other774.tables;
++GetTablesResult::GetTablesResult(const GetTablesResult& other796) {
++  tables = other796.tables;
+ }
 -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other775) {
 -  tables = other775.tables;
++GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other797) {
++  tables = other797.tables;
+   return *this;
+ }
+ void GetTablesResult::printTo(std::ostream& out) const {
+   using ::apache::thrift::to_string;
+   out << "GetTablesResult(";
+   out << "tables=" << to_string(tables);
+   out << ")";
+ }
+ 
+ 
  TableMeta::~TableMeta() throw() {
  }
  
@@@ -18850,19 -18510,19 +19445,19 @@@ void swap(TableMeta &a, TableMeta &b) 
    swap(a.__isset, b.__isset);
  }
  
- TableMeta::TableMeta(const TableMeta& other769) {
-   dbName = other769.dbName;
-   tableName = other769.tableName;
-   tableType = other769.tableType;
-   comments = other769.comments;
-   __isset = other769.__isset;
 -TableMeta::TableMeta(const TableMeta& other776) {
 -  dbName = other776.dbName;
 -  tableName = other776.tableName;
 -  tableType = other776.tableType;
 -  comments = other776.comments;
 -  __isset = other776.__isset;
++TableMeta::TableMeta(const TableMeta& other798) {
++  dbName = other798.dbName;
++  tableName = other798.tableName;
++  tableType = other798.tableType;
++  comments = other798.comments;
++  __isset = other798.__isset;
  }
- TableMeta& TableMeta::operator=(const TableMeta& other770) {
-   dbName = other770.dbName;
-   tableName = other770.tableName;
-   tableType = other770.tableType;
-   comments = other770.comments;
-   __isset = other770.__isset;
 -TableMeta& TableMeta::operator=(const TableMeta& other777) {
 -  dbName = other777.dbName;
 -  tableName = other777.tableName;
 -  tableType = other777.tableType;
 -  comments = other777.comments;
 -  __isset = other777.__isset;
++TableMeta& TableMeta::operator=(const TableMeta& other799) {
++  dbName = other799.dbName;
++  tableName = other799.tableName;
++  tableType = other799.tableType;
++  comments = other799.comments;
++  __isset = other799.__isset;
    return *this;
  }
  void TableMeta::printTo(std::ostream& out) const {
@@@ -18945,13 -18605,13 +19540,13 @@@ void swap(MetaException &a, MetaExcepti
    swap(a.__isset, b.__isset);
  }
  
- MetaException::MetaException(const MetaException& other771) : TException() {
-   message = other771.message;
-   __isset = other771.__isset;
 -MetaException::MetaException(const MetaException& other778) : TException() {
 -  message = other778.message;
 -  __isset = other778.__isset;
++MetaException::MetaException(const MetaException& other800) : TException() {
++  message = other800.message;
++  __isset = other800.__isset;
  }
- MetaException& MetaException::operator=(const MetaException& other772) {
-   message = other772.message;
-   __isset = other772.__isset;
 -MetaException& MetaException::operator=(const MetaException& other779) {
 -  message = other779.message;
 -  __isset = other779.__isset;
++MetaException& MetaException::operator=(const MetaException& other801) {
++  message = other801.message;
++  __isset = other801.__isset;
    return *this;
  }
  void MetaException::printTo(std::ostream& out) const {
@@@ -19042,13 -18702,13 +19637,13 @@@ void swap(UnknownTableException &a, Unk
    swap(a.__isset, b.__isset);
  }
  
- UnknownTableException::UnknownTableException(const UnknownTableException& other773) : TException() {
-   message = other773.message;
-   __isset = other773.__isset;
 -UnknownTableException::UnknownTableException(const UnknownTableException& other780) : TException() {
 -  message = other780.message;
 -  __isset = other780.__isset;
++UnknownTableException::UnknownTableException(const UnknownTableException& other802) : TException() {
++  message = other802.message;
++  __isset = other802.__isset;
  }
- UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other774) {
-   message = other774.message;
-   __isset = other774.__isset;
 -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other781) {
 -  message = other781.message;
 -  __isset = other781.__isset;
++UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other803) {
++  message = other803.message;
++  __isset = other803.__isset;
    return *this;
  }
  void UnknownTableException::printTo(std::ostream& out) const {
@@@ -19139,13 -18799,13 +19734,13 @@@ void swap(UnknownDBException &a, Unknow
    swap(a.__isset, b.__isset);
  }
  
- UnknownDBException::UnknownDBException(const UnknownDBException& other775) : TException() {
-   message = other775.message;
-   __isset = other775.__isset;
 -UnknownDBException::UnknownDBException(const UnknownDBException& other782) : TException() {
 -  message = other782.message;
 -  __isset = other782.__isset;
++UnknownDBException::UnknownDBException(const UnknownDBException& other804) : TException() {
++  message = other804.message;
++  __isset = other804.__isset;
  }
- UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other776) {
-   message = other776.message;
-   __isset = other776.__isset;
 -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other783) {
 -  message = other783.message;
 -  __isset = other783.__isset;
++UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other805) {
++  message = other805.message;
++  __isset = other805.__isset;
    return *this;
  }
  void UnknownDBException::printTo(std::ostream& out) const {
@@@ -19236,13 -18896,13 +19831,13 @@@ void swap(AlreadyExistsException &a, Al
    swap(a.__isset, b.__isset);
  }
  
- AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other777) : TException() {
-   message = other777.message;
-   __isset = other777.__isset;
 -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other784) : TException() {
 -  message = other784.message;
 -  __isset = other784.__isset;
++AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other806) : TException() {
++  message = other806.message;
++  __isset = other806.__isset;
  }
- AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other778) {
-   message = other778.message;
-   __isset = other778.__isset;
 -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other785) {
 -  message = other785.message;
 -  __isset = other785.__isset;
++AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other807) {
++  message = other807.message;
++  __isset = other807.__isset;
    return *this;
  }
  void AlreadyExistsException::printTo(std::ostream& out) const {
@@@ -19333,13 -18993,13 +19928,13 @@@ void swap(InvalidPartitionException &a
    swap(a.__isset, b.__isset);
  }
  
- InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other779) : TException() {
-   message = other779.message;
-   __isset = other779.__isset;
 -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other786) : TException() {
 -  message = other786.message;
 -  __isset = other786.__isset;
++InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other808) : TException() {
++  message = other808.message;
++  __isset = other808.__isset;
  }
- InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other780) {
-   message = other780.message;
-   __isset = other780.__isset;
 -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other787) {
 -  message = other787.message;
 -  __isset = other787.__isset;
++InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other809) {
++  message = other809.message;
++  __isset = other809.__isset;
    return *this;
  }
  void InvalidPartitionException::printTo(std::ostream& out) const {
@@@ -19430,13 -19090,13 +20025,13 @@@ void swap(UnknownPartitionException &a
    swap(a.__isset, b.__isset);
  }
  
- UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other781) : TException() {
-   message = other781.message;
-   __isset = other781.__isset;
 -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other788) : TException() {
 -  message = other788.message;
 -  __isset = other788.__isset;
++UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other810) : TException() {
++  message = other810.message;
++  __isset = other810.__isset;
  }
- UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other782) {
-   message = other782.message;
-   __isset = other782.__isset;
 -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other789) {
 -  message = other789.message;
 -  __isset = other789.__isset;
++UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other811) {
++  message = other811.message;
++  __isset = other811.__isset;
    return *this;
  }
  void UnknownPartitionException::printTo(std::ostream& out) const {
@@@ -19527,13 -19187,13 +20122,13 @@@ void swap(InvalidObjectException &a, In
    swap(a.__isset, b.__isset);
  }
  
- InvalidObjectException::InvalidObjectException(const InvalidObjectException& other783) : TException() {
-   message = other783.message;
-   __isset = other783.__isset;
 -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other790) : TException() {
 -  message = other790.message;
 -  __isset = other790.__isset;
++InvalidObjectException::InvalidObjectException(const InvalidObjectException& other812) : TException() {
++  message = other812.message;
++  __isset = other812.__isset;
  }
- InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other784) {
-   message = other784.message;
-   __isset = other784.__isset;
 -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other791) {
 -  message = other791.message;
 -  __isset = other791.__isset;
++InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other813) {
++  message = other813.message;
++  __isset = other813.__isset;
    return *this;
  }
  void InvalidObjectException::printTo(std::ostream& out) const {
@@@ -19624,13 -19284,13 +20219,13 @@@ void swap(NoSuchObjectException &a, NoS
    swap(a.__isset, b.__isset);
  }
  
- NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other785) : TException() {
-   message = other785.message;
-   __isset = other785.__isset;
 -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other792) : TException() {
 -  message = other792.message;
 -  __isset = other792.__isset;
++NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other814) : TException() {
++  message = other814.message;
++  __isset = other814.__isset;
  }
- NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other786) {
-   message = other786.message;
-   __isset = other786.__isset;
 -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other793) {
 -  message = other793.message;
 -  __isset = other793.__isset;
++NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other815) {
++  message = other815.message;
++  __isset = other815.__isset;
    return *this;
  }
  void NoSuchObjectException::printTo(std::ostream& out) const {
@@@ -19721,13 -19381,13 +20316,13 @@@ void swap(IndexAlreadyExistsException &
    swap(a.__isset, b.__isset);
  }
  
- IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other787) : TException() {
-   message = other787.message;
-   __isset = other787.__isset;
 -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other794) : TException() {
 -  message = other794.message;
 -  __isset = other794.__isset;
++IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other816) : TException() {
++  message = other816.message;
++  __isset = other816.__isset;
  }
- IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other788) {
-   message = other788.message;
-   __isset = other788.__isset;
 -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other795) {
 -  message = other795.message;
 -  __isset = other795.__isset;
++IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other817) {
++  message = other817.message;
++  __isset = other817.__isset;
    return *this;
  }
  void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@@ -19818,13 -19478,13 +20413,13 @@@ void swap(InvalidOperationException &a
    swap(a.__isset, b.__isset);
  }
  
- InvalidOperationException::InvalidOperationException(const InvalidOperationException& other789) : TException() {
-   message = other789.message;
-   __isset = other789.__isset;
 -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other796) : TException() {
 -  message = other796.message;
 -  __isset = other796.__isset;
++InvalidOperationException::InvalidOperationException(const InvalidOperationException& other818) : TException() {
++  message = other818.message;
++  __isset = other818.__isset;
  }
- InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other790) {
-   message = other790.message;
-   __isset = other790.__isset;
 -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other797) {
 -  message = other797.message;
 -  __isset = other797.__isset;
++InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other819) {
++  message = other819.message;
++  __isset = other819.__isset;
    return *this;
  }
  void InvalidOperationException::printTo(std::ostream& out) const {
@@@ -19915,13 -19575,13 +20510,13 @@@ void swap(ConfigValSecurityException &a
    swap(a.__isset, b.__isset);
  }
  
- ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other791) : TException() {
-   message = other791.message;
-   __isset = other791.__isset;
 -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other798) : TException() {
 -  message = other798.message;
 -  __isset = other798.__isset;
++ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other820) : TException() {
++  message = other820.message;
++  __isset = other820.__isset;
  }
- ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other792) {
-   message = other792.message;
-   __isset = other792.__isset;
 -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other799) {
 -  message = other799.message;
 -  __isset = other799.__isset;
++ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other821) {
++  message = other821.message;
++  __isset = other821.__isset;
    return *this;
  }
  void ConfigValSecurityException::printTo(std::ostream& out) const {
@@@ -20012,13 -19672,13 +20607,13 @@@ void swap(InvalidInputException &a, Inv
    swap(a.__isset, b.__isset);
  }
  
- InvalidInputException::InvalidInputException(const InvalidInputException& other793) : TException() {
-   message = other793.message;
-   __isset = other793.__isset;
 -InvalidInputException::InvalidInputException(const InvalidInputException& other800) : TException() {
 -  message = other800.message;
 -  __isset = other800.__isset;
++InvalidInputException::InvalidInputException(const InvalidInputException& other822) : TException() {
++  message = other822.message;
++  __isset = other822.__isset;
  }
- InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other794) {
-   message = other794.message;
-   __isset = other794.__isset;
 -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other801) {
 -  message = other801.message;
 -  __isset = other801.__isset;
++InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other823) {
++  message = other823.message;
++  __isset = other823.__isset;
    return *this;
  }
  void InvalidInputException::printTo(std::ostream& out) const {
@@@ -20109,13 -19769,13 +20704,13 @@@ void swap(NoSuchTxnException &a, NoSuch
    swap(a.__isset, b.__isset);
  }
  
- NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other795) : TException() {
-   message = other795.message;
-   __isset = other795.__isset;
 -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other802) : TException() {
 -  message = other802.message;
 -  __isset = other802.__isset;
++NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other824) : TException() {
++  message = other824.message;
++  __isset = other824.__isset;
  }
- NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other796) {
-   message = other796.message;
-   __isset = other796.__isset;
 -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other803) {
 -  message = other803.message;
 -  __isset = other803.__isset;
++NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other825) {
++  message = other825.message;
++  __isset = other825.__isset;
    return *this;
  }
  void NoSuchTxnException::printTo(std::ostream& out) const {
@@@ -20206,13 -19866,13 +20801,13 @@@ void swap(TxnAbortedException &a, TxnAb
    swap(a.__isset, b.__isset);
  }
  
- TxnAbortedException::TxnAbortedException(const TxnAbortedException& other797) : TException() {
-   message = other797.message;
-   __isset = other797.__isset;
 -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other804) : TException() {
 -  message = other804.message;
 -  __isset = other804.__isset;
++TxnAbortedException::TxnAbortedException(const TxnAbortedException& other826) : TException() {
++  message = other826.message;
++  __isset = other826.__isset;
  }
- TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other798) {
-   message = other798.message;
-   __isset = other798.__isset;
 -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other805) {
 -  message = other805.message;
 -  __isset = other805.__isset;
++TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other827) {
++  message = other827.message;
++  __isset = other827.__isset;
    return *this;
  }
  void TxnAbortedException::printTo(std::ostream& out) const {
@@@ -20303,13 -19963,13 +20898,13 @@@ void swap(TxnOpenException &a, TxnOpenE
    swap(a.__isset, b.__isset);
  }
  
- TxnOpenException::TxnOpenException(const TxnOpenException& other799) : TException() {
-   message = other799.message;
-   __isset = other799.__isset;
 -TxnOpenException::TxnOpenException(const TxnOpenException& other806) : TException() {
 -  message = other806.message;
 -  __isset = other806.__isset;
++TxnOpenException::TxnOpenException(const TxnOpenException& other828) : TException() {
++  message = other828.message;
++  __isset = other828.__isset;
  }
- TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other800) {
-   message = other800.message;
-   __isset = other800.__isset;
 -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other807) {
 -  message = other807.message;
 -  __isset = other807.__isset;
++TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other829) {
++  message = other829.message;
++  __isset = other829.__isset;
    return *this;
  }
  void TxnOpenException::printTo(std::ostream& out) const {
@@@ -20400,13 -20060,13 +20995,13 @@@ void swap(NoSuchLockException &a, NoSuc
    swap(a.__isset, b.__isset);
  }
  
- NoSuchLockException::NoSuchLockException(const NoSuchLockException& other801) : TException() {
-   message = other801.message;
-   __isset = other801.__isset;
 -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other808) : TException() {
 -  message = other808.message;
 -  __isset = other808.__isset;
++NoSuchLockException::NoSuchLockException(const NoSuchLockException& other830) : TException() {
++  message = other830.message;
++  __isset = other830.__isset;
  }
- NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other802) {
-   message = other802.message;
-   __isset = other802.__isset;
 -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other809) {
 -  message = other809.message;
 -  __isset = other809.__isset;
++NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other831) {
++  message = other831.message;
++  __isset = other831.__isset;
    return *this;
  }
  void NoSuchLockException::printTo(std::ostream& out) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/b3914c37/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 87d9664,70fe2c3..236ad15
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@@ -384,24 -392,18 +392,34 @@@ class CacheFileMetadataResult
  
  class CacheFileMetadataRequest;
  
 +class GetNextWriteIdRequest;
 +
 +class GetNextWriteIdResult;
 +
 +class FinalizeWriteIdRequest;
 +
 +class FinalizeWriteIdResult;
 +
 +class HeartbeatWriteIdRequest;
 +
 +class HeartbeatWriteIdResult;
 +
 +class GetValidWriteIdsRequest;
 +
 +class GetValidWriteIdsResult;
 +
  class GetAllFunctionsResponse;
  
+ class ClientCapabilities;
+ 
+ class GetTableRequest;
+ 
+ class GetTableResult;
+ 
+ class GetTablesRequest;
+ 
+ class GetTablesResult;
+ 
  class TableMeta;
  
  class MetaException;

http://git-wip-us.apache.org/repos/asf/hive/blob/b3914c37/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
index 0000000,5fc7d56..81534fe
mode 000000,100644..100644
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ClientCapabilities.java
@@@ -1,0 -1,441 +1,441 @@@
+ /**
+  * 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 ClientCapabilities implements org.apache.thrift.TBase<ClientCapabilities, ClientCapabilities._Fields>, java.io.Serializable, Cloneable, Comparable<ClientCapabilities> {
+   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ClientCapabilities");
+ 
+   private static final org.apache.thrift.protocol.TField VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.LIST, (short)1);
+ 
+   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+   static {
+     schemes.put(StandardScheme.class, new ClientCapabilitiesStandardSchemeFactory());
+     schemes.put(TupleScheme.class, new ClientCapabilitiesTupleSchemeFactory());
+   }
+ 
+   private List<ClientCapability> values; // required
+ 
+   /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+   public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+     VALUES((short)1, "values");
+ 
+     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: // VALUES
+           return VALUES;
+         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
+   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.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+             new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, ClientCapability.class))));
+     metaDataMap = Collections.unmodifiableMap(tmpMap);
+     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ClientCapabilities.class, metaDataMap);
+   }
+ 
+   public ClientCapabilities() {
+   }
+ 
+   public ClientCapabilities(
+     List<ClientCapability> values)
+   {
+     this();
+     this.values = values;
+   }
+ 
+   /**
+    * Performs a deep copy on <i>other</i>.
+    */
+   public ClientCapabilities(ClientCapabilities other) {
+     if (other.isSetValues()) {
+       List<ClientCapability> __this__values = new ArrayList<ClientCapability>(other.values.size());
+       for (ClientCapability other_element : other.values) {
+         __this__values.add(other_element);
+       }
+       this.values = __this__values;
+     }
+   }
+ 
+   public ClientCapabilities deepCopy() {
+     return new ClientCapabilities(this);
+   }
+ 
+   @Override
+   public void clear() {
+     this.values = null;
+   }
+ 
+   public int getValuesSize() {
+     return (this.values == null) ? 0 : this.values.size();
+   }
+ 
+   public java.util.Iterator<ClientCapability> getValuesIterator() {
+     return (this.values == null) ? null : this.values.iterator();
+   }
+ 
+   public void addToValues(ClientCapability elem) {
+     if (this.values == null) {
+       this.values = new ArrayList<ClientCapability>();
+     }
+     this.values.add(elem);
+   }
+ 
+   public List<ClientCapability> getValues() {
+     return this.values;
+   }
+ 
+   public void setValues(List<ClientCapability> values) {
+     this.values = values;
+   }
+ 
+   public void unsetValues() {
+     this.values = null;
+   }
+ 
+   /** Returns true if field values is set (has been assigned a value) and false otherwise */
+   public boolean isSetValues() {
+     return this.values != null;
+   }
+ 
+   public void setValuesIsSet(boolean value) {
+     if (!value) {
+       this.values = null;
+     }
+   }
+ 
+   public void setFieldValue(_Fields field, Object value) {
+     switch (field) {
+     case VALUES:
+       if (value == null) {
+         unsetValues();
+       } else {
+         setValues((List<ClientCapability>)value);
+       }
+       break;
+ 
+     }
+   }
+ 
+   public Object getFieldValue(_Fields field) {
+     switch (field) {
+     case VALUES:
+       return getValues();
+ 
+     }
+     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 VALUES:
+       return isSetValues();
+     }
+     throw new IllegalStateException();
+   }
+ 
+   @Override
+   public boolean equals(Object that) {
+     if (that == null)
+       return false;
+     if (that instanceof ClientCapabilities)
+       return this.equals((ClientCapabilities)that);
+     return false;
+   }
+ 
+   public boolean equals(ClientCapabilities that) {
+     if (that == null)
+       return false;
+ 
+     boolean this_present_values = true && this.isSetValues();
+     boolean that_present_values = true && that.isSetValues();
+     if (this_present_values || that_present_values) {
+       if (!(this_present_values && that_present_values))
+         return false;
+       if (!this.values.equals(that.values))
+         return false;
+     }
+ 
+     return true;
+   }
+ 
+   @Override
+   public int hashCode() {
+     List<Object> list = new ArrayList<Object>();
+ 
+     boolean present_values = true && (isSetValues());
+     list.add(present_values);
+     if (present_values)
+       list.add(values);
+ 
+     return list.hashCode();
+   }
+ 
+   @Override
+   public int compareTo(ClientCapabilities other) {
+     if (!getClass().equals(other.getClass())) {
+       return getClass().getName().compareTo(other.getClass().getName());
+     }
+ 
+     int lastComparison = 0;
+ 
+     lastComparison = Boolean.valueOf(isSetValues()).compareTo(other.isSetValues());
+     if (lastComparison != 0) {
+       return lastComparison;
+     }
+     if (isSetValues()) {
+       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, other.values);
+       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("ClientCapabilities(");
+     boolean first = true;
+ 
+     sb.append("values:");
+     if (this.values == null) {
+       sb.append("null");
+     } else {
+       sb.append(this.values);
+     }
+     first = false;
+     sb.append(")");
+     return sb.toString();
+   }
+ 
+   public void validate() throws org.apache.thrift.TException {
+     // check for required fields
+     if (!isSetValues()) {
+       throw new org.apache.thrift.protocol.TProtocolException("Required field 'values' 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 {
+       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 ClientCapabilitiesStandardSchemeFactory implements SchemeFactory {
+     public ClientCapabilitiesStandardScheme getScheme() {
+       return new ClientCapabilitiesStandardScheme();
+     }
+   }
+ 
+   private static class ClientCapabilitiesStandardScheme extends StandardScheme<ClientCapabilities> {
+ 
+     public void read(org.apache.thrift.protocol.TProtocol iprot, ClientCapabilities 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: // VALUES
+             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+               {
 -                org.apache.thrift.protocol.TList _list642 = iprot.readListBegin();
 -                struct.values = new ArrayList<ClientCapability>(_list642.size);
 -                ClientCapability _elem643;
 -                for (int _i644 = 0; _i644 < _list642.size; ++_i644)
++                org.apache.thrift.protocol.TList _list650 = iprot.readListBegin();
++                struct.values = new ArrayList<ClientCapability>(_list650.size);
++                ClientCapability _elem651;
++                for (int _i652 = 0; _i652 < _list650.size; ++_i652)
+                 {
 -                  _elem643 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
 -                  struct.values.add(_elem643);
++                  _elem651 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
++                  struct.values.add(_elem651);
+                 }
+                 iprot.readListEnd();
+               }
+               struct.setValuesIsSet(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, ClientCapabilities struct) throws org.apache.thrift.TException {
+       struct.validate();
+ 
+       oprot.writeStructBegin(STRUCT_DESC);
+       if (struct.values != null) {
+         oprot.writeFieldBegin(VALUES_FIELD_DESC);
+         {
+           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.values.size()));
 -          for (ClientCapability _iter645 : struct.values)
++          for (ClientCapability _iter653 : struct.values)
+           {
 -            oprot.writeI32(_iter645.getValue());
++            oprot.writeI32(_iter653.getValue());
+           }
+           oprot.writeListEnd();
+         }
+         oprot.writeFieldEnd();
+       }
+       oprot.writeFieldStop();
+       oprot.writeStructEnd();
+     }
+ 
+   }
+ 
+   private static class ClientCapabilitiesTupleSchemeFactory implements SchemeFactory {
+     public ClientCapabilitiesTupleScheme getScheme() {
+       return new ClientCapabilitiesTupleScheme();
+     }
+   }
+ 
+   private static class ClientCapabilitiesTupleScheme extends TupleScheme<ClientCapabilities> {
+ 
+     @Override
+     public void write(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException {
+       TTupleProtocol oprot = (TTupleProtocol) prot;
+       {
+         oprot.writeI32(struct.values.size());
 -        for (ClientCapability _iter646 : struct.values)
++        for (ClientCapability _iter654 : struct.values)
+         {
 -          oprot.writeI32(_iter646.getValue());
++          oprot.writeI32(_iter654.getValue());
+         }
+       }
+     }
+ 
+     @Override
+     public void read(org.apache.thrift.protocol.TProtocol prot, ClientCapabilities struct) throws org.apache.thrift.TException {
+       TTupleProtocol iprot = (TTupleProtocol) prot;
+       {
 -        org.apache.thrift.protocol.TList _list647 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
 -        struct.values = new ArrayList<ClientCapability>(_list647.size);
 -        ClientCapability _elem648;
 -        for (int _i649 = 0; _i649 < _list647.size; ++_i649)
++        org.apache.thrift.protocol.TList _list655 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
++        struct.values = new ArrayList<ClientCapability>(_list655.size);
++        ClientCapability _elem656;
++        for (int _i657 = 0; _i657 < _list655.size; ++_i657)
+         {
 -          _elem648 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
 -          struct.values.add(_elem648);
++          _elem656 = org.apache.hadoop.hive.metastore.api.ClientCapability.findByValue(iprot.readI32());
++          struct.values.add(_elem656);
+         }
+       }
+       struct.setValuesIsSet(true);
+     }
+   }
+ 
+ }
+ 


Mime
View raw message