You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2016/11/15 20:21:20 UTC
[48/50] [abbrv] hive git commit: HIVE-14671 : merge master into
hive-14535 (exim conflicts merge 1) (Sergey Shelukhin)
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);
+ }
+ }
+
+ }
+