hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From w...@apache.org
Subject [47/50] [abbrv] hive git commit: HIVE-14671 : merge master into hive-14535 (Wei Zheng)
Date Mon, 08 May 2017 22:18:04 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/1ceaf357/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --cc metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 96c2b0b,e3725a5..cfa2e49
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@@ -18058,26 -18056,25 +18102,26 @@@ uint32_t GetNextWriteIdRequest::write(:
    return xfer;
  }
  
 -void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
 +void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b) {
    using ::std::swap;
 -  swap(a.functions, b.functions);
 -  swap(a.__isset, b.__isset);
 +  swap(a.dbName, b.dbName);
 +  swap(a.tblName, b.tblName);
  }
  
- GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other747) {
 -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other752) {
 -  functions = other752.functions;
 -  __isset = other752.__isset;
++GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other746) {
++  dbName = other746.dbName;
++  tblName = other746.tblName;
+ }
 -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other753) {
 -  functions = other753.functions;
 -  __isset = other753.__isset;
++GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other747) {
 +  dbName = other747.dbName;
 +  tblName = other747.tblName;
- }
- GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other748) {
-   dbName = other748.dbName;
-   tblName = other748.tblName;
    return *this;
  }
 -void GetAllFunctionsResponse::printTo(std::ostream& out) const {
 +void GetNextWriteIdRequest::printTo(std::ostream& out) const {
    using ::apache::thrift::to_string;
 -  out << "GetAllFunctionsResponse(";
 -  out << "functions="; (__isset.functions ? (out << to_string(functions)) : (out << "<null>"));
 +  out << "GetNextWriteIdRequest(";
 +  out << "dbName=" << to_string(dbName);
 +  out << ", " << "tblName=" << to_string(tblName);
    out << ")";
  }
  
@@@ -18148,22 -18167,22 +18192,22 @@@ uint32_t GetNextWriteIdResult::write(::
    return xfer;
  }
  
 -void swap(ClientCapabilities &a, ClientCapabilities &b) {
 +void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b) {
    using ::std::swap;
 -  swap(a.values, b.values);
 +  swap(a.writeId, b.writeId);
  }
  
- GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other749) {
-   writeId = other749.writeId;
 -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other761) {
 -  values = other761.values;
++GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other748) {
++  writeId = other748.writeId;
  }
- GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other750) {
-   writeId = other750.writeId;
 -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other762) {
 -  values = other762.values;
++GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other749) {
++  writeId = other749.writeId;
    return *this;
  }
 -void ClientCapabilities::printTo(std::ostream& out) const {
 +void GetNextWriteIdResult::printTo(std::ostream& out) const {
    using ::apache::thrift::to_string;
 -  out << "ClientCapabilities(";
 -  out << "values=" << to_string(values);
 +  out << "GetNextWriteIdResult(";
 +  out << "writeId=" << to_string(writeId);
    out << ")";
  }
  
@@@ -18295,30 -18294,29 +18339,30 @@@ void swap(FinalizeWriteIdRequest &a, Fi
    using ::std::swap;
    swap(a.dbName, b.dbName);
    swap(a.tblName, b.tblName);
 -  swap(a.capabilities, b.capabilities);
 -  swap(a.__isset, b.__isset);
 +  swap(a.writeId, b.writeId);
 +  swap(a.commit, b.commit);
  }
  
- FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other751) {
 -GetTableRequest::GetTableRequest(const GetTableRequest& other763) {
 -  dbName = other763.dbName;
 -  tblName = other763.tblName;
 -  capabilities = other763.capabilities;
 -  __isset = other763.__isset;
++FinalizeWriteIdRequest::FinalizeWriteIdRequest(const FinalizeWriteIdRequest& other750) {
++  dbName = other750.dbName;
++  tblName = other750.tblName;
++  writeId = other750.writeId;
++  commit = other750.commit;
+ }
 -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other764) {
 -  dbName = other764.dbName;
 -  tblName = other764.tblName;
 -  capabilities = other764.capabilities;
 -  __isset = other764.__isset;
++FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other751) {
 +  dbName = other751.dbName;
 +  tblName = other751.tblName;
 +  writeId = other751.writeId;
 +  commit = other751.commit;
- }
- FinalizeWriteIdRequest& FinalizeWriteIdRequest::operator=(const FinalizeWriteIdRequest& other752) {
-   dbName = other752.dbName;
-   tblName = other752.tblName;
-   writeId = other752.writeId;
-   commit = other752.commit;
    return *this;
  }
 -void GetTableRequest::printTo(std::ostream& out) const {
 +void FinalizeWriteIdRequest::printTo(std::ostream& out) const {
    using ::apache::thrift::to_string;
 -  out << "GetTableRequest(";
 +  out << "FinalizeWriteIdRequest(";
    out << "dbName=" << to_string(dbName);
    out << ", " << "tblName=" << to_string(tblName);
 -  out << ", " << "capabilities="; (__isset.capabilities ? (out << to_string(capabilities)) : (out << "<null>"));
 +  out << ", " << "writeId=" << to_string(writeId);
 +  out << ", " << "commit=" << to_string(commit);
    out << ")";
  }
  
@@@ -18365,22 -18387,22 +18409,22 @@@ uint32_t FinalizeWriteIdResult::write(:
    return xfer;
  }
  
 -void swap(GetTableResult &a, GetTableResult &b) {
 +void swap(FinalizeWriteIdResult &a, FinalizeWriteIdResult &b) {
    using ::std::swap;
 -  swap(a.table, b.table);
 +  (void) a;
 +  (void) b;
  }
  
- FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other753) {
-   (void) other753;
 -GetTableResult::GetTableResult(const GetTableResult& other765) {
 -  table = other765.table;
++FinalizeWriteIdResult::FinalizeWriteIdResult(const FinalizeWriteIdResult& other752) {
++  (void) other752;
  }
- FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other754) {
-   (void) other754;
 -GetTableResult& GetTableResult::operator=(const GetTableResult& other766) {
 -  table = other766.table;
++FinalizeWriteIdResult& FinalizeWriteIdResult::operator=(const FinalizeWriteIdResult& other753) {
++  (void) other753;
    return *this;
  }
 -void GetTableResult::printTo(std::ostream& out) const {
 +void FinalizeWriteIdResult::printTo(std::ostream& out) const {
    using ::apache::thrift::to_string;
 -  out << "GetTableResult(";
 -  out << "table=" << to_string(table);
 +  out << "FinalizeWriteIdResult(";
    out << ")";
  }
  
@@@ -18489,30 -18529,33 +18533,30 @@@ uint32_t HeartbeatWriteIdRequest::write
    return xfer;
  }
  
 -void swap(GetTablesRequest &a, GetTablesRequest &b) {
 +void swap(HeartbeatWriteIdRequest &a, HeartbeatWriteIdRequest &b) {
    using ::std::swap;
    swap(a.dbName, b.dbName);
 -  swap(a.tblNames, b.tblNames);
 -  swap(a.capabilities, b.capabilities);
 -  swap(a.__isset, b.__isset);
 +  swap(a.tblName, b.tblName);
 +  swap(a.writeId, b.writeId);
  }
  
- HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other755) {
 -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other773) {
 -  dbName = other773.dbName;
 -  tblNames = other773.tblNames;
 -  capabilities = other773.capabilities;
 -  __isset = other773.__isset;
++HeartbeatWriteIdRequest::HeartbeatWriteIdRequest(const HeartbeatWriteIdRequest& other754) {
++  dbName = other754.dbName;
++  tblName = other754.tblName;
++  writeId = other754.writeId;
+ }
 -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other774) {
 -  dbName = other774.dbName;
 -  tblNames = other774.tblNames;
 -  capabilities = other774.capabilities;
 -  __isset = other774.__isset;
++HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other755) {
 +  dbName = other755.dbName;
 +  tblName = other755.tblName;
 +  writeId = other755.writeId;
- }
- HeartbeatWriteIdRequest& HeartbeatWriteIdRequest::operator=(const HeartbeatWriteIdRequest& other756) {
-   dbName = other756.dbName;
-   tblName = other756.tblName;
-   writeId = other756.writeId;
    return *this;
  }
 -void GetTablesRequest::printTo(std::ostream& out) const {
 +void HeartbeatWriteIdRequest::printTo(std::ostream& out) const {
    using ::apache::thrift::to_string;
 -  out << "GetTablesRequest(";
 +  out << "HeartbeatWriteIdRequest(";
    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 << ", " << "tblName=" << to_string(tblName);
 +  out << ", " << "writeId=" << to_string(writeId);
    out << ")";
  }
  
@@@ -18521,947 -18564,11 +18565,947 @@@ HeartbeatWriteIdResult::~HeartbeatWrite
  }
  
  
 -void GetTablesResult::__set_tables(const std::vector<Table> & val) {
 -  this->tables = val;
 -}
 -
 -uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 +uint32_t HeartbeatWriteIdResult::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& other757) {
-   (void) other757;
++HeartbeatWriteIdResult::HeartbeatWriteIdResult(const HeartbeatWriteIdResult& other756) {
++  (void) other756;
 +}
- HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other758) {
-   (void) other758;
++HeartbeatWriteIdResult& HeartbeatWriteIdResult::operator=(const HeartbeatWriteIdResult& other757) {
++  (void) other757;
 +  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& other759) {
++GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other758) {
++  dbName = other758.dbName;
++  tblName = other758.tblName;
++}
++GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other759) {
 +  dbName = other759.dbName;
 +  tblName = other759.tblName;
- }
- GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other760) {
-   dbName = other760.dbName;
-   tblName = other760.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 _size761;
-             ::apache::thrift::protocol::TType _etype764;
-             xfer += iprot->readListBegin(_etype764, _size761);
-             this->ids.resize(_size761);
-             uint32_t _i765;
-             for (_i765 = 0; _i765 < _size761; ++_i765)
++            uint32_t _size760;
++            ::apache::thrift::protocol::TType _etype763;
++            xfer += iprot->readListBegin(_etype763, _size760);
++            this->ids.resize(_size760);
++            uint32_t _i764;
++            for (_i764 = 0; _i764 < _size760; ++_i764)
 +            {
-               xfer += iprot->readI64(this->ids[_i765]);
++              xfer += iprot->readI64(this->ids[_i764]);
 +            }
 +            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 _iter766;
-       for (_iter766 = this->ids.begin(); _iter766 != this->ids.end(); ++_iter766)
++      std::vector<int64_t> ::const_iterator _iter765;
++      for (_iter765 = this->ids.begin(); _iter765 != this->ids.end(); ++_iter765)
 +      {
-         xfer += oprot->writeI64((*_iter766));
++        xfer += oprot->writeI64((*_iter765));
 +      }
 +      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& other767) {
++GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other766) {
++  lowWatermarkId = other766.lowWatermarkId;
++  highWatermarkId = other766.highWatermarkId;
++  areIdsValid = other766.areIdsValid;
++  ids = other766.ids;
++  __isset = other766.__isset;
++}
++GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other767) {
 +  lowWatermarkId = other767.lowWatermarkId;
 +  highWatermarkId = other767.highWatermarkId;
 +  areIdsValid = other767.areIdsValid;
 +  ids = other767.ids;
 +  __isset = other767.__isset;
- }
- GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other768) {
-   lowWatermarkId = other768.lowWatermarkId;
-   highWatermarkId = other768.highWatermarkId;
-   areIdsValid = other768.areIdsValid;
-   ids = other768.ids;
-   __isset = other768.__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 _size769;
-             ::apache::thrift::protocol::TType _etype772;
-             xfer += iprot->readListBegin(_etype772, _size769);
-             this->functions.resize(_size769);
-             uint32_t _i773;
-             for (_i773 = 0; _i773 < _size769; ++_i773)
++            uint32_t _size768;
++            ::apache::thrift::protocol::TType _etype771;
++            xfer += iprot->readListBegin(_etype771, _size768);
++            this->functions.resize(_size768);
++            uint32_t _i772;
++            for (_i772 = 0; _i772 < _size768; ++_i772)
 +            {
-               xfer += this->functions[_i773].read(iprot);
++              xfer += this->functions[_i772].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 _iter774;
-       for (_iter774 = this->functions.begin(); _iter774 != this->functions.end(); ++_iter774)
++      std::vector<Function> ::const_iterator _iter773;
++      for (_iter773 = this->functions.begin(); _iter773 != this->functions.end(); ++_iter773)
 +      {
-         xfer += (*_iter774).write(oprot);
++        xfer += (*_iter773).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& other775) {
++GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other774) {
++  functions = other774.functions;
++  __isset = other774.__isset;
++}
++GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other775) {
 +  functions = other775.functions;
 +  __isset = other775.__isset;
- }
- GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other776) {
-   functions = other776.functions;
-   __isset = other776.__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 _size777;
-             ::apache::thrift::protocol::TType _etype780;
-             xfer += iprot->readListBegin(_etype780, _size777);
-             this->values.resize(_size777);
-             uint32_t _i781;
-             for (_i781 = 0; _i781 < _size777; ++_i781)
++            uint32_t _size776;
++            ::apache::thrift::protocol::TType _etype779;
++            xfer += iprot->readListBegin(_etype779, _size776);
++            this->values.resize(_size776);
++            uint32_t _i780;
++            for (_i780 = 0; _i780 < _size776; ++_i780)
 +            {
-               int32_t ecast782;
-               xfer += iprot->readI32(ecast782);
-               this->values[_i781] = (ClientCapability::type)ecast782;
++              int32_t ecast781;
++              xfer += iprot->readI32(ecast781);
++              this->values[_i780] = (ClientCapability::type)ecast781;
 +            }
 +            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 _iter783;
-     for (_iter783 = this->values.begin(); _iter783 != this->values.end(); ++_iter783)
++    std::vector<ClientCapability::type> ::const_iterator _iter782;
++    for (_iter782 = this->values.begin(); _iter782 != this->values.end(); ++_iter782)
 +    {
-       xfer += oprot->writeI32((int32_t)(*_iter783));
++      xfer += oprot->writeI32((int32_t)(*_iter782));
 +    }
 +    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& other784) {
-   values = other784.values;
++ClientCapabilities::ClientCapabilities(const ClientCapabilities& other783) {
++  values = other783.values;
 +}
- ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other785) {
-   values = other785.values;
++ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other784) {
++  values = other784.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& other786) {
++GetTableRequest::GetTableRequest(const GetTableRequest& other785) {
++  dbName = other785.dbName;
++  tblName = other785.tblName;
++  capabilities = other785.capabilities;
++  __isset = other785.__isset;
++}
++GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other786) {
 +  dbName = other786.dbName;
 +  tblName = other786.tblName;
 +  capabilities = other786.capabilities;
 +  __isset = other786.__isset;
- }
- GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other787) {
-   dbName = other787.dbName;
-   tblName = other787.tblName;
-   capabilities = other787.capabilities;
-   __isset = other787.__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& other788) {
-   table = other788.table;
++GetTableResult::GetTableResult(const GetTableResult& other787) {
++  table = other787.table;
 +}
- GetTableResult& GetTableResult::operator=(const GetTableResult& other789) {
-   table = other789.table;
++GetTableResult& GetTableResult::operator=(const GetTableResult& other788) {
++  table = other788.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 _size790;
-             ::apache::thrift::protocol::TType _etype793;
-             xfer += iprot->readListBegin(_etype793, _size790);
-             this->tblNames.resize(_size790);
-             uint32_t _i794;
-             for (_i794 = 0; _i794 < _size790; ++_i794)
++            uint32_t _size789;
++            ::apache::thrift::protocol::TType _etype792;
++            xfer += iprot->readListBegin(_etype792, _size789);
++            this->tblNames.resize(_size789);
++            uint32_t _i793;
++            for (_i793 = 0; _i793 < _size789; ++_i793)
 +            {
-               xfer += iprot->readString(this->tblNames[_i794]);
++              xfer += iprot->readString(this->tblNames[_i793]);
 +            }
 +            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 _iter795;
-       for (_iter795 = this->tblNames.begin(); _iter795 != this->tblNames.end(); ++_iter795)
++      std::vector<std::string> ::const_iterator _iter794;
++      for (_iter794 = this->tblNames.begin(); _iter794 != this->tblNames.end(); ++_iter794)
 +      {
-         xfer += oprot->writeString((*_iter795));
++        xfer += oprot->writeString((*_iter794));
 +      }
 +      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& other796) {
++GetTablesRequest::GetTablesRequest(const GetTablesRequest& other795) {
++  dbName = other795.dbName;
++  tblNames = other795.tblNames;
++  capabilities = other795.capabilities;
++  __isset = other795.__isset;
++}
++GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other796) {
 +  dbName = other796.dbName;
 +  tblNames = other796.tblNames;
 +  capabilities = other796.capabilities;
 +  __isset = other796.__isset;
- }
- GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other797) {
-   dbName = other797.dbName;
-   tblNames = other797.tblNames;
-   capabilities = other797.capabilities;
-   __isset = other797.__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;
@@@ -19487,14 -18594,14 +19531,14 @@@
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->tables.clear();
-             uint32_t _size798;
-             ::apache::thrift::protocol::TType _etype801;
-             xfer += iprot->readListBegin(_etype801, _size798);
-             this->tables.resize(_size798);
-             uint32_t _i802;
-             for (_i802 = 0; _i802 < _size798; ++_i802)
 -            uint32_t _size775;
 -            ::apache::thrift::protocol::TType _etype778;
 -            xfer += iprot->readListBegin(_etype778, _size775);
 -            this->tables.resize(_size775);
 -            uint32_t _i779;
 -            for (_i779 = 0; _i779 < _size775; ++_i779)
++            uint32_t _size797;
++            ::apache::thrift::protocol::TType _etype800;
++            xfer += iprot->readListBegin(_etype800, _size797);
++            this->tables.resize(_size797);
++            uint32_t _i801;
++            for (_i801 = 0; _i801 < _size797; ++_i801)
              {
-               xfer += this->tables[_i802].read(iprot);
 -              xfer += this->tables[_i779].read(iprot);
++              xfer += this->tables[_i801].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@@ -19525,10 -18632,10 +19569,10 @@@ uint32_t GetTablesResult::write(::apach
    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 _iter803;
-     for (_iter803 = this->tables.begin(); _iter803 != this->tables.end(); ++_iter803)
 -    std::vector<Table> ::const_iterator _iter780;
 -    for (_iter780 = this->tables.begin(); _iter780 != this->tables.end(); ++_iter780)
++    std::vector<Table> ::const_iterator _iter802;
++    for (_iter802 = this->tables.begin(); _iter802 != this->tables.end(); ++_iter802)
      {
-       xfer += (*_iter803).write(oprot);
 -      xfer += (*_iter780).write(oprot);
++      xfer += (*_iter802).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@@ -19544,11 -18651,11 +19588,11 @@@ void swap(GetTablesResult &a, GetTables
    swap(a.tables, b.tables);
  }
  
- GetTablesResult::GetTablesResult(const GetTablesResult& other804) {
-   tables = other804.tables;
 -GetTablesResult::GetTablesResult(const GetTablesResult& other781) {
 -  tables = other781.tables;
++GetTablesResult::GetTablesResult(const GetTablesResult& other803) {
++  tables = other803.tables;
  }
- GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other805) {
-   tables = other805.tables;
 -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other782) {
 -  tables = other782.tables;
++GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other804) {
++  tables = other804.tables;
    return *this;
  }
  void GetTablesResult::printTo(std::ostream& out) const {
@@@ -19690,19 -18797,19 +19734,19 @@@ void swap(TableMeta &a, TableMeta &b) 
    swap(a.__isset, b.__isset);
  }
  
- TableMeta::TableMeta(const TableMeta& other806) {
 -TableMeta::TableMeta(const TableMeta& other783) {
 -  dbName = other783.dbName;
 -  tableName = other783.tableName;
 -  tableType = other783.tableType;
 -  comments = other783.comments;
 -  __isset = other783.__isset;
++TableMeta::TableMeta(const TableMeta& other805) {
++  dbName = other805.dbName;
++  tableName = other805.tableName;
++  tableType = other805.tableType;
++  comments = other805.comments;
++  __isset = other805.__isset;
+ }
 -TableMeta& TableMeta::operator=(const TableMeta& other784) {
 -  dbName = other784.dbName;
 -  tableName = other784.tableName;
 -  tableType = other784.tableType;
 -  comments = other784.comments;
 -  __isset = other784.__isset;
++TableMeta& TableMeta::operator=(const TableMeta& other806) {
 +  dbName = other806.dbName;
 +  tableName = other806.tableName;
 +  tableType = other806.tableType;
 +  comments = other806.comments;
 +  __isset = other806.__isset;
- }
- TableMeta& TableMeta::operator=(const TableMeta& other807) {
-   dbName = other807.dbName;
-   tableName = other807.tableName;
-   tableType = other807.tableType;
-   comments = other807.comments;
-   __isset = other807.__isset;
    return *this;
  }
  void TableMeta::printTo(std::ostream& out) const {
@@@ -19785,13 -18892,13 +19829,13 @@@ void swap(MetaException &a, MetaExcepti
    swap(a.__isset, b.__isset);
  }
  
- MetaException::MetaException(const MetaException& other808) : TException() {
 -MetaException::MetaException(const MetaException& other785) : TException() {
 -  message = other785.message;
 -  __isset = other785.__isset;
++MetaException::MetaException(const MetaException& other807) : TException() {
++  message = other807.message;
++  __isset = other807.__isset;
+ }
 -MetaException& MetaException::operator=(const MetaException& other786) {
 -  message = other786.message;
 -  __isset = other786.__isset;
++MetaException& MetaException::operator=(const MetaException& other808) {
 +  message = other808.message;
 +  __isset = other808.__isset;
- }
- MetaException& MetaException::operator=(const MetaException& other809) {
-   message = other809.message;
-   __isset = other809.__isset;
    return *this;
  }
  void MetaException::printTo(std::ostream& out) const {
@@@ -19882,13 -18989,13 +19926,13 @@@ void swap(UnknownTableException &a, Unk
    swap(a.__isset, b.__isset);
  }
  
- UnknownTableException::UnknownTableException(const UnknownTableException& other810) : TException() {
 -UnknownTableException::UnknownTableException(const UnknownTableException& other787) : TException() {
 -  message = other787.message;
 -  __isset = other787.__isset;
++UnknownTableException::UnknownTableException(const UnknownTableException& other809) : TException() {
++  message = other809.message;
++  __isset = other809.__isset;
+ }
 -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other788) {
 -  message = other788.message;
 -  __isset = other788.__isset;
++UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other810) {
 +  message = other810.message;
 +  __isset = other810.__isset;
- }
- UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other811) {
-   message = other811.message;
-   __isset = other811.__isset;
    return *this;
  }
  void UnknownTableException::printTo(std::ostream& out) const {
@@@ -19979,13 -19086,13 +20023,13 @@@ void swap(UnknownDBException &a, Unknow
    swap(a.__isset, b.__isset);
  }
  
- UnknownDBException::UnknownDBException(const UnknownDBException& other812) : TException() {
 -UnknownDBException::UnknownDBException(const UnknownDBException& other789) : TException() {
 -  message = other789.message;
 -  __isset = other789.__isset;
++UnknownDBException::UnknownDBException(const UnknownDBException& other811) : TException() {
++  message = other811.message;
++  __isset = other811.__isset;
+ }
 -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other790) {
 -  message = other790.message;
 -  __isset = other790.__isset;
++UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other812) {
 +  message = other812.message;
 +  __isset = other812.__isset;
- }
- UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other813) {
-   message = other813.message;
-   __isset = other813.__isset;
    return *this;
  }
  void UnknownDBException::printTo(std::ostream& out) const {
@@@ -20076,13 -19183,13 +20120,13 @@@ void swap(AlreadyExistsException &a, Al
    swap(a.__isset, b.__isset);
  }
  
- AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other814) : TException() {
 -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other791) : TException() {
 -  message = other791.message;
 -  __isset = other791.__isset;
++AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other813) : TException() {
++  message = other813.message;
++  __isset = other813.__isset;
+ }
 -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other792) {
 -  message = other792.message;
 -  __isset = other792.__isset;
++AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other814) {
 +  message = other814.message;
 +  __isset = other814.__isset;
- }
- AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other815) {
-   message = other815.message;
-   __isset = other815.__isset;
    return *this;
  }
  void AlreadyExistsException::printTo(std::ostream& out) const {
@@@ -20173,13 -19280,13 +20217,13 @@@ void swap(InvalidPartitionException &a
    swap(a.__isset, b.__isset);
  }
  
- InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other816) : TException() {
 -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other793) : TException() {
 -  message = other793.message;
 -  __isset = other793.__isset;
++InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other815) : TException() {
++  message = other815.message;
++  __isset = other815.__isset;
+ }
 -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other794) {
 -  message = other794.message;
 -  __isset = other794.__isset;
++InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other816) {
 +  message = other816.message;
 +  __isset = other816.__isset;
- }
- InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other817) {
-   message = other817.message;
-   __isset = other817.__isset;
    return *this;
  }
  void InvalidPartitionException::printTo(std::ostream& out) const {
@@@ -20270,13 -19377,13 +20314,13 @@@ void swap(UnknownPartitionException &a
    swap(a.__isset, b.__isset);
  }
  
- UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other818) : TException() {
 -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other795) : TException() {
 -  message = other795.message;
 -  __isset = other795.__isset;
++UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other817) : TException() {
++  message = other817.message;
++  __isset = other817.__isset;
+ }
 -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other796) {
 -  message = other796.message;
 -  __isset = other796.__isset;
++UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other818) {
 +  message = other818.message;
 +  __isset = other818.__isset;
- }
- UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other819) {
-   message = other819.message;
-   __isset = other819.__isset;
    return *this;
  }
  void UnknownPartitionException::printTo(std::ostream& out) const {
@@@ -20367,13 -19474,13 +20411,13 @@@ void swap(InvalidObjectException &a, In
    swap(a.__isset, b.__isset);
  }
  
- InvalidObjectException::InvalidObjectException(const InvalidObjectException& other820) : TException() {
 -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other797) : TException() {
 -  message = other797.message;
 -  __isset = other797.__isset;
++InvalidObjectException::InvalidObjectException(const InvalidObjectException& other819) : TException() {
++  message = other819.message;
++  __isset = other819.__isset;
+ }
 -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other798) {
 -  message = other798.message;
 -  __isset = other798.__isset;
++InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other820) {
 +  message = other820.message;
 +  __isset = other820.__isset;
- }
- InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other821) {
-   message = other821.message;
-   __isset = other821.__isset;
    return *this;
  }
  void InvalidObjectException::printTo(std::ostream& out) const {
@@@ -20464,13 -19571,13 +20508,13 @@@ void swap(NoSuchObjectException &a, NoS
    swap(a.__isset, b.__isset);
  }
  
- NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other822) : TException() {
 -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other799) : TException() {
 -  message = other799.message;
 -  __isset = other799.__isset;
++NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other821) : TException() {
++  message = other821.message;
++  __isset = other821.__isset;
+ }
 -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other800) {
 -  message = other800.message;
 -  __isset = other800.__isset;
++NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other822) {
 +  message = other822.message;
 +  __isset = other822.__isset;
- }
- NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other823) {
-   message = other823.message;
-   __isset = other823.__isset;
    return *this;
  }
  void NoSuchObjectException::printTo(std::ostream& out) const {
@@@ -20561,13 -19668,13 +20605,13 @@@ void swap(IndexAlreadyExistsException &
    swap(a.__isset, b.__isset);
  }
  
- IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other824) : TException() {
 -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other801) : TException() {
 -  message = other801.message;
 -  __isset = other801.__isset;
++IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other823) : TException() {
++  message = other823.message;
++  __isset = other823.__isset;
+ }
 -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other802) {
 -  message = other802.message;
 -  __isset = other802.__isset;
++IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other824) {
 +  message = other824.message;
 +  __isset = other824.__isset;
- }
- IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other825) {
-   message = other825.message;
-   __isset = other825.__isset;
    return *this;
  }
  void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@@ -20658,13 -19765,13 +20702,13 @@@ void swap(InvalidOperationException &a
    swap(a.__isset, b.__isset);
  }
  
- InvalidOperationException::InvalidOperationException(const InvalidOperationException& other826) : TException() {
 -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other803) : TException() {
 -  message = other803.message;
 -  __isset = other803.__isset;
++InvalidOperationException::InvalidOperationException(const InvalidOperationException& other825) : TException() {
++  message = other825.message;
++  __isset = other825.__isset;
+ }
 -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other804) {
 -  message = other804.message;
 -  __isset = other804.__isset;
++InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other826) {
 +  message = other826.message;
 +  __isset = other826.__isset;
- }
- InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other827) {
-   message = other827.message;
-   __isset = other827.__isset;
    return *this;
  }
  void InvalidOperationException::printTo(std::ostream& out) const {
@@@ -20755,13 -19862,13 +20799,13 @@@ void swap(ConfigValSecurityException &a
    swap(a.__isset, b.__isset);
  }
  
- ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other828) : TException() {
 -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other805) : TException() {
 -  message = other805.message;
 -  __isset = other805.__isset;
++ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other827) : TException() {
++  message = other827.message;
++  __isset = other827.__isset;
+ }
 -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other806) {
 -  message = other806.message;
 -  __isset = other806.__isset;
++ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other828) {
 +  message = other828.message;
 +  __isset = other828.__isset;
- }
- ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other829) {
-   message = other829.message;
-   __isset = other829.__isset;
    return *this;
  }
  void ConfigValSecurityException::printTo(std::ostream& out) const {
@@@ -20852,13 -19959,13 +20896,13 @@@ void swap(InvalidInputException &a, Inv
    swap(a.__isset, b.__isset);
  }
  
- InvalidInputException::InvalidInputException(const InvalidInputException& other830) : TException() {
 -InvalidInputException::InvalidInputException(const InvalidInputException& other807) : TException() {
 -  message = other807.message;
 -  __isset = other807.__isset;
++InvalidInputException::InvalidInputException(const InvalidInputException& other829) : TException() {
++  message = other829.message;
++  __isset = other829.__isset;
+ }
 -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other808) {
 -  message = other808.message;
 -  __isset = other808.__isset;
++InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other830) {
 +  message = other830.message;
 +  __isset = other830.__isset;
- }
- InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other831) {
-   message = other831.message;
-   __isset = other831.__isset;
    return *this;
  }
  void InvalidInputException::printTo(std::ostream& out) const {
@@@ -20949,13 -20056,13 +20993,13 @@@ void swap(NoSuchTxnException &a, NoSuch
    swap(a.__isset, b.__isset);
  }
  
- NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other832) : TException() {
 -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other809) : TException() {
 -  message = other809.message;
 -  __isset = other809.__isset;
++NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other831) : TException() {
++  message = other831.message;
++  __isset = other831.__isset;
+ }
 -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other810) {
 -  message = other810.message;
 -  __isset = other810.__isset;
++NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other832) {
 +  message = other832.message;
 +  __isset = other832.__isset;
- }
- NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other833) {
-   message = other833.message;
-   __isset = other833.__isset;
    return *this;
  }
  void NoSuchTxnException::printTo(std::ostream& out) const {
@@@ -21046,13 -20153,13 +21090,13 @@@ void swap(TxnAbortedException &a, TxnAb
    swap(a.__isset, b.__isset);
  }
  
- TxnAbortedException::TxnAbortedException(const TxnAbortedException& other834) : TException() {
 -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other811) : TException() {
 -  message = other811.message;
 -  __isset = other811.__isset;
++TxnAbortedException::TxnAbortedException(const TxnAbortedException& other833) : TException() {
++  message = other833.message;
++  __isset = other833.__isset;
+ }
 -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other812) {
 -  message = other812.message;
 -  __isset = other812.__isset;
++TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other834) {
 +  message = other834.message;
 +  __isset = other834.__isset;
- }
- TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other835) {
-   message = other835.message;
-   __isset = other835.__isset;
    return *this;
  }
  void TxnAbortedException::printTo(std::ostream& out) const {
@@@ -21143,13 -20250,13 +21187,13 @@@ void swap(TxnOpenException &a, TxnOpenE
    swap(a.__isset, b.__isset);
  }
  
- TxnOpenException::TxnOpenException(const TxnOpenException& other836) : TException() {
 -TxnOpenException::TxnOpenException(const TxnOpenException& other813) : TException() {
 -  message = other813.message;
 -  __isset = other813.__isset;
++TxnOpenException::TxnOpenException(const TxnOpenException& other835) : TException() {
++  message = other835.message;
++  __isset = other835.__isset;
+ }
 -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other814) {
 -  message = other814.message;
 -  __isset = other814.__isset;
++TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other836) {
 +  message = other836.message;
 +  __isset = other836.__isset;
- }
- TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other837) {
-   message = other837.message;
-   __isset = other837.__isset;
    return *this;
  }
  void TxnOpenException::printTo(std::ostream& out) const {
@@@ -21240,13 -20347,13 +21284,13 @@@ void swap(NoSuchLockException &a, NoSuc
    swap(a.__isset, b.__isset);
  }
  
- NoSuchLockException::NoSuchLockException(const NoSuchLockException& other838) : TException() {
 -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other815) : TException() {
 -  message = other815.message;
 -  __isset = other815.__isset;
++NoSuchLockException::NoSuchLockException(const NoSuchLockException& other837) : TException() {
++  message = other837.message;
++  __isset = other837.__isset;
+ }
 -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other816) {
 -  message = other816.message;
 -  __isset = other816.__isset;
++NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other838) {
 +  message = other838.message;
 +  __isset = other838.__isset;
- }
- NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other839) {
-   message = other839.message;
-   __isset = other839.__isset;
    return *this;
  }
  void NoSuchLockException::printTo(std::ostream& out) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/1ceaf357/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------


Mime
View raw message