You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by dj...@apache.org on 2018/05/08 18:42:15 UTC
[10/58] [abbrv] hive git commit: HIVE-18988: Support bootstrap
replication of ACID tables (Sankar Hariappan, reviewed by Mahesh Kumar Behera,
Thejas M Nair)
http://git-wip-us.apache.org/repos/asf/hive/blob/4c0475ff/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 2fab857..acdace1 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -16540,6 +16540,229 @@ void CommitTxnRequest::printTo(std::ostream& out) const {
}
+ReplTblWriteIdStateRequest::~ReplTblWriteIdStateRequest() throw() {
+}
+
+
+void ReplTblWriteIdStateRequest::__set_validWriteIdlist(const std::string& val) {
+ this->validWriteIdlist = val;
+}
+
+void ReplTblWriteIdStateRequest::__set_user(const std::string& val) {
+ this->user = val;
+}
+
+void ReplTblWriteIdStateRequest::__set_hostName(const std::string& val) {
+ this->hostName = val;
+}
+
+void ReplTblWriteIdStateRequest::__set_dbName(const std::string& val) {
+ this->dbName = val;
+}
+
+void ReplTblWriteIdStateRequest::__set_tableName(const std::string& val) {
+ this->tableName = val;
+}
+
+void ReplTblWriteIdStateRequest::__set_partNames(const std::vector<std::string> & val) {
+ this->partNames = val;
+__isset.partNames = true;
+}
+
+uint32_t ReplTblWriteIdStateRequest::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_validWriteIdlist = false;
+ bool isset_user = false;
+ bool isset_hostName = false;
+ bool isset_dbName = false;
+ bool isset_tableName = 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->validWriteIdlist);
+ isset_validWriteIdlist = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->user);
+ isset_user = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->hostName);
+ isset_hostName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbName);
+ isset_dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableName);
+ isset_tableName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->partNames.clear();
+ uint32_t _size672;
+ ::apache::thrift::protocol::TType _etype675;
+ xfer += iprot->readListBegin(_etype675, _size672);
+ this->partNames.resize(_size672);
+ uint32_t _i676;
+ for (_i676 = 0; _i676 < _size672; ++_i676)
+ {
+ xfer += iprot->readString(this->partNames[_i676]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.partNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_validWriteIdlist)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_user)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_hostName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tableName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t ReplTblWriteIdStateRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ReplTblWriteIdStateRequest");
+
+ xfer += oprot->writeFieldBegin("validWriteIdlist", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->validWriteIdlist);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->user);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("hostName", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->hostName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->tableName);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.partNames) {
+ xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size()));
+ std::vector<std::string> ::const_iterator _iter677;
+ for (_iter677 = this->partNames.begin(); _iter677 != this->partNames.end(); ++_iter677)
+ {
+ xfer += oprot->writeString((*_iter677));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) {
+ using ::std::swap;
+ swap(a.validWriteIdlist, b.validWriteIdlist);
+ swap(a.user, b.user);
+ swap(a.hostName, b.hostName);
+ swap(a.dbName, b.dbName);
+ swap(a.tableName, b.tableName);
+ swap(a.partNames, b.partNames);
+ swap(a.__isset, b.__isset);
+}
+
+ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other678) {
+ validWriteIdlist = other678.validWriteIdlist;
+ user = other678.user;
+ hostName = other678.hostName;
+ dbName = other678.dbName;
+ tableName = other678.tableName;
+ partNames = other678.partNames;
+ __isset = other678.__isset;
+}
+ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other679) {
+ validWriteIdlist = other679.validWriteIdlist;
+ user = other679.user;
+ hostName = other679.hostName;
+ dbName = other679.dbName;
+ tableName = other679.tableName;
+ partNames = other679.partNames;
+ __isset = other679.__isset;
+ return *this;
+}
+void ReplTblWriteIdStateRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "ReplTblWriteIdStateRequest(";
+ out << "validWriteIdlist=" << to_string(validWriteIdlist);
+ out << ", " << "user=" << to_string(user);
+ out << ", " << "hostName=" << to_string(hostName);
+ out << ", " << "dbName=" << to_string(dbName);
+ out << ", " << "tableName=" << to_string(tableName);
+ out << ", " << "partNames="; (__isset.partNames ? (out << to_string(partNames)) : (out << "<null>"));
+ out << ")";
+}
+
+
GetValidWriteIdsRequest::~GetValidWriteIdsRequest() throw() {
}
@@ -16579,14 +16802,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fullTableNames.clear();
- uint32_t _size672;
- ::apache::thrift::protocol::TType _etype675;
- xfer += iprot->readListBegin(_etype675, _size672);
- this->fullTableNames.resize(_size672);
- uint32_t _i676;
- for (_i676 = 0; _i676 < _size672; ++_i676)
+ uint32_t _size680;
+ ::apache::thrift::protocol::TType _etype683;
+ xfer += iprot->readListBegin(_etype683, _size680);
+ this->fullTableNames.resize(_size680);
+ uint32_t _i684;
+ for (_i684 = 0; _i684 < _size680; ++_i684)
{
- xfer += iprot->readString(this->fullTableNames[_i676]);
+ xfer += iprot->readString(this->fullTableNames[_i684]);
}
xfer += iprot->readListEnd();
}
@@ -16627,10 +16850,10 @@ uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* o
xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->fullTableNames.size()));
- std::vector<std::string> ::const_iterator _iter677;
- for (_iter677 = this->fullTableNames.begin(); _iter677 != this->fullTableNames.end(); ++_iter677)
+ std::vector<std::string> ::const_iterator _iter685;
+ for (_iter685 = this->fullTableNames.begin(); _iter685 != this->fullTableNames.end(); ++_iter685)
{
- xfer += oprot->writeString((*_iter677));
+ xfer += oprot->writeString((*_iter685));
}
xfer += oprot->writeListEnd();
}
@@ -16651,13 +16874,13 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) {
swap(a.validTxnList, b.validTxnList);
}
-GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other678) {
- fullTableNames = other678.fullTableNames;
- validTxnList = other678.validTxnList;
+GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other686) {
+ fullTableNames = other686.fullTableNames;
+ validTxnList = other686.validTxnList;
}
-GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other679) {
- fullTableNames = other679.fullTableNames;
- validTxnList = other679.validTxnList;
+GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other687) {
+ fullTableNames = other687.fullTableNames;
+ validTxnList = other687.validTxnList;
return *this;
}
void GetValidWriteIdsRequest::printTo(std::ostream& out) const {
@@ -16739,14 +16962,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->invalidWriteIds.clear();
- uint32_t _size680;
- ::apache::thrift::protocol::TType _etype683;
- xfer += iprot->readListBegin(_etype683, _size680);
- this->invalidWriteIds.resize(_size680);
- uint32_t _i684;
- for (_i684 = 0; _i684 < _size680; ++_i684)
+ uint32_t _size688;
+ ::apache::thrift::protocol::TType _etype691;
+ xfer += iprot->readListBegin(_etype691, _size688);
+ this->invalidWriteIds.resize(_size688);
+ uint32_t _i692;
+ for (_i692 = 0; _i692 < _size688; ++_i692)
{
- xfer += iprot->readI64(this->invalidWriteIds[_i684]);
+ xfer += iprot->readI64(this->invalidWriteIds[_i692]);
}
xfer += iprot->readListEnd();
}
@@ -16807,10 +17030,10 @@ uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->invalidWriteIds.size()));
- std::vector<int64_t> ::const_iterator _iter685;
- for (_iter685 = this->invalidWriteIds.begin(); _iter685 != this->invalidWriteIds.end(); ++_iter685)
+ std::vector<int64_t> ::const_iterator _iter693;
+ for (_iter693 = this->invalidWriteIds.begin(); _iter693 != this->invalidWriteIds.end(); ++_iter693)
{
- xfer += oprot->writeI64((*_iter685));
+ xfer += oprot->writeI64((*_iter693));
}
xfer += oprot->writeListEnd();
}
@@ -16840,21 +17063,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) {
swap(a.__isset, b.__isset);
}
-TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other686) {
- fullTableName = other686.fullTableName;
- writeIdHighWaterMark = other686.writeIdHighWaterMark;
- invalidWriteIds = other686.invalidWriteIds;
- minOpenWriteId = other686.minOpenWriteId;
- abortedBits = other686.abortedBits;
- __isset = other686.__isset;
-}
-TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other687) {
- fullTableName = other687.fullTableName;
- writeIdHighWaterMark = other687.writeIdHighWaterMark;
- invalidWriteIds = other687.invalidWriteIds;
- minOpenWriteId = other687.minOpenWriteId;
- abortedBits = other687.abortedBits;
- __isset = other687.__isset;
+TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other694) {
+ fullTableName = other694.fullTableName;
+ writeIdHighWaterMark = other694.writeIdHighWaterMark;
+ invalidWriteIds = other694.invalidWriteIds;
+ minOpenWriteId = other694.minOpenWriteId;
+ abortedBits = other694.abortedBits;
+ __isset = other694.__isset;
+}
+TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other695) {
+ fullTableName = other695.fullTableName;
+ writeIdHighWaterMark = other695.writeIdHighWaterMark;
+ invalidWriteIds = other695.invalidWriteIds;
+ minOpenWriteId = other695.minOpenWriteId;
+ abortedBits = other695.abortedBits;
+ __isset = other695.__isset;
return *this;
}
void TableValidWriteIds::printTo(std::ostream& out) const {
@@ -16903,14 +17126,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tblValidWriteIds.clear();
- uint32_t _size688;
- ::apache::thrift::protocol::TType _etype691;
- xfer += iprot->readListBegin(_etype691, _size688);
- this->tblValidWriteIds.resize(_size688);
- uint32_t _i692;
- for (_i692 = 0; _i692 < _size688; ++_i692)
+ uint32_t _size696;
+ ::apache::thrift::protocol::TType _etype699;
+ xfer += iprot->readListBegin(_etype699, _size696);
+ this->tblValidWriteIds.resize(_size696);
+ uint32_t _i700;
+ for (_i700 = 0; _i700 < _size696; ++_i700)
{
- xfer += this->tblValidWriteIds[_i692].read(iprot);
+ xfer += this->tblValidWriteIds[_i700].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -16941,10 +17164,10 @@ uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tblValidWriteIds.size()));
- std::vector<TableValidWriteIds> ::const_iterator _iter693;
- for (_iter693 = this->tblValidWriteIds.begin(); _iter693 != this->tblValidWriteIds.end(); ++_iter693)
+ std::vector<TableValidWriteIds> ::const_iterator _iter701;
+ for (_iter701 = this->tblValidWriteIds.begin(); _iter701 != this->tblValidWriteIds.end(); ++_iter701)
{
- xfer += (*_iter693).write(oprot);
+ xfer += (*_iter701).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -16960,11 +17183,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) {
swap(a.tblValidWriteIds, b.tblValidWriteIds);
}
-GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other694) {
- tblValidWriteIds = other694.tblValidWriteIds;
+GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other702) {
+ tblValidWriteIds = other702.tblValidWriteIds;
}
-GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other695) {
- tblValidWriteIds = other695.tblValidWriteIds;
+GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other703) {
+ tblValidWriteIds = other703.tblValidWriteIds;
return *this;
}
void GetValidWriteIdsResponse::printTo(std::ostream& out) const {
@@ -17045,14 +17268,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txnIds.clear();
- uint32_t _size696;
- ::apache::thrift::protocol::TType _etype699;
- xfer += iprot->readListBegin(_etype699, _size696);
- this->txnIds.resize(_size696);
- uint32_t _i700;
- for (_i700 = 0; _i700 < _size696; ++_i700)
+ uint32_t _size704;
+ ::apache::thrift::protocol::TType _etype707;
+ xfer += iprot->readListBegin(_etype707, _size704);
+ this->txnIds.resize(_size704);
+ uint32_t _i708;
+ for (_i708 = 0; _i708 < _size704; ++_i708)
{
- xfer += iprot->readI64(this->txnIds[_i700]);
+ xfer += iprot->readI64(this->txnIds[_i708]);
}
xfer += iprot->readListEnd();
}
@@ -17073,14 +17296,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->srcTxnToWriteIdList.clear();
- uint32_t _size701;
- ::apache::thrift::protocol::TType _etype704;
- xfer += iprot->readListBegin(_etype704, _size701);
- this->srcTxnToWriteIdList.resize(_size701);
- uint32_t _i705;
- for (_i705 = 0; _i705 < _size701; ++_i705)
+ uint32_t _size709;
+ ::apache::thrift::protocol::TType _etype712;
+ xfer += iprot->readListBegin(_etype712, _size709);
+ this->srcTxnToWriteIdList.resize(_size709);
+ uint32_t _i713;
+ for (_i713 = 0; _i713 < _size709; ++_i713)
{
- xfer += this->srcTxnToWriteIdList[_i705].read(iprot);
+ xfer += this->srcTxnToWriteIdList[_i713].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17122,10 +17345,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc
xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txnIds.size()));
- std::vector<int64_t> ::const_iterator _iter706;
- for (_iter706 = this->txnIds.begin(); _iter706 != this->txnIds.end(); ++_iter706)
+ std::vector<int64_t> ::const_iterator _iter714;
+ for (_iter714 = this->txnIds.begin(); _iter714 != this->txnIds.end(); ++_iter714)
{
- xfer += oprot->writeI64((*_iter706));
+ xfer += oprot->writeI64((*_iter714));
}
xfer += oprot->writeListEnd();
}
@@ -17140,10 +17363,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc
xfer += oprot->writeFieldBegin("srcTxnToWriteIdList", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->srcTxnToWriteIdList.size()));
- std::vector<TxnToWriteId> ::const_iterator _iter707;
- for (_iter707 = this->srcTxnToWriteIdList.begin(); _iter707 != this->srcTxnToWriteIdList.end(); ++_iter707)
+ std::vector<TxnToWriteId> ::const_iterator _iter715;
+ for (_iter715 = this->srcTxnToWriteIdList.begin(); _iter715 != this->srcTxnToWriteIdList.end(); ++_iter715)
{
- xfer += (*_iter707).write(oprot);
+ xfer += (*_iter715).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17164,21 +17387,21 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) {
swap(a.__isset, b.__isset);
}
-AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other708) {
- dbName = other708.dbName;
- tableName = other708.tableName;
- txnIds = other708.txnIds;
- replPolicy = other708.replPolicy;
- srcTxnToWriteIdList = other708.srcTxnToWriteIdList;
- __isset = other708.__isset;
-}
-AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other709) {
- dbName = other709.dbName;
- tableName = other709.tableName;
- txnIds = other709.txnIds;
- replPolicy = other709.replPolicy;
- srcTxnToWriteIdList = other709.srcTxnToWriteIdList;
- __isset = other709.__isset;
+AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other716) {
+ dbName = other716.dbName;
+ tableName = other716.tableName;
+ txnIds = other716.txnIds;
+ replPolicy = other716.replPolicy;
+ srcTxnToWriteIdList = other716.srcTxnToWriteIdList;
+ __isset = other716.__isset;
+}
+AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other717) {
+ dbName = other717.dbName;
+ tableName = other717.tableName;
+ txnIds = other717.txnIds;
+ replPolicy = other717.replPolicy;
+ srcTxnToWriteIdList = other717.srcTxnToWriteIdList;
+ __isset = other717.__isset;
return *this;
}
void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const {
@@ -17284,13 +17507,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) {
swap(a.writeId, b.writeId);
}
-TxnToWriteId::TxnToWriteId(const TxnToWriteId& other710) {
- txnId = other710.txnId;
- writeId = other710.writeId;
+TxnToWriteId::TxnToWriteId(const TxnToWriteId& other718) {
+ txnId = other718.txnId;
+ writeId = other718.writeId;
}
-TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other711) {
- txnId = other711.txnId;
- writeId = other711.writeId;
+TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other719) {
+ txnId = other719.txnId;
+ writeId = other719.writeId;
return *this;
}
void TxnToWriteId::printTo(std::ostream& out) const {
@@ -17336,14 +17559,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txnToWriteIds.clear();
- uint32_t _size712;
- ::apache::thrift::protocol::TType _etype715;
- xfer += iprot->readListBegin(_etype715, _size712);
- this->txnToWriteIds.resize(_size712);
- uint32_t _i716;
- for (_i716 = 0; _i716 < _size712; ++_i716)
+ uint32_t _size720;
+ ::apache::thrift::protocol::TType _etype723;
+ xfer += iprot->readListBegin(_etype723, _size720);
+ this->txnToWriteIds.resize(_size720);
+ uint32_t _i724;
+ for (_i724 = 0; _i724 < _size720; ++_i724)
{
- xfer += this->txnToWriteIds[_i716].read(iprot);
+ xfer += this->txnToWriteIds[_i724].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17374,10 +17597,10 @@ uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProto
xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->txnToWriteIds.size()));
- std::vector<TxnToWriteId> ::const_iterator _iter717;
- for (_iter717 = this->txnToWriteIds.begin(); _iter717 != this->txnToWriteIds.end(); ++_iter717)
+ std::vector<TxnToWriteId> ::const_iterator _iter725;
+ for (_iter725 = this->txnToWriteIds.begin(); _iter725 != this->txnToWriteIds.end(); ++_iter725)
{
- xfer += (*_iter717).write(oprot);
+ xfer += (*_iter725).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17393,11 +17616,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) {
swap(a.txnToWriteIds, b.txnToWriteIds);
}
-AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other718) {
- txnToWriteIds = other718.txnToWriteIds;
+AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other726) {
+ txnToWriteIds = other726.txnToWriteIds;
}
-AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other719) {
- txnToWriteIds = other719.txnToWriteIds;
+AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other727) {
+ txnToWriteIds = other727.txnToWriteIds;
return *this;
}
void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const {
@@ -17475,9 +17698,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast720;
- xfer += iprot->readI32(ecast720);
- this->type = (LockType::type)ecast720;
+ int32_t ecast728;
+ xfer += iprot->readI32(ecast728);
+ this->type = (LockType::type)ecast728;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -17485,9 +17708,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast721;
- xfer += iprot->readI32(ecast721);
- this->level = (LockLevel::type)ecast721;
+ int32_t ecast729;
+ xfer += iprot->readI32(ecast729);
+ this->level = (LockLevel::type)ecast729;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -17519,9 +17742,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast722;
- xfer += iprot->readI32(ecast722);
- this->operationType = (DataOperationType::type)ecast722;
+ int32_t ecast730;
+ xfer += iprot->readI32(ecast730);
+ this->operationType = (DataOperationType::type)ecast730;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -17621,27 +17844,27 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other723) {
- type = other723.type;
- level = other723.level;
- dbname = other723.dbname;
- tablename = other723.tablename;
- partitionname = other723.partitionname;
- operationType = other723.operationType;
- isTransactional = other723.isTransactional;
- isDynamicPartitionWrite = other723.isDynamicPartitionWrite;
- __isset = other723.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other724) {
- type = other724.type;
- level = other724.level;
- dbname = other724.dbname;
- tablename = other724.tablename;
- partitionname = other724.partitionname;
- operationType = other724.operationType;
- isTransactional = other724.isTransactional;
- isDynamicPartitionWrite = other724.isDynamicPartitionWrite;
- __isset = other724.__isset;
+LockComponent::LockComponent(const LockComponent& other731) {
+ type = other731.type;
+ level = other731.level;
+ dbname = other731.dbname;
+ tablename = other731.tablename;
+ partitionname = other731.partitionname;
+ operationType = other731.operationType;
+ isTransactional = other731.isTransactional;
+ isDynamicPartitionWrite = other731.isDynamicPartitionWrite;
+ __isset = other731.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other732) {
+ type = other732.type;
+ level = other732.level;
+ dbname = other732.dbname;
+ tablename = other732.tablename;
+ partitionname = other732.partitionname;
+ operationType = other732.operationType;
+ isTransactional = other732.isTransactional;
+ isDynamicPartitionWrite = other732.isDynamicPartitionWrite;
+ __isset = other732.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -17713,14 +17936,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size725;
- ::apache::thrift::protocol::TType _etype728;
- xfer += iprot->readListBegin(_etype728, _size725);
- this->component.resize(_size725);
- uint32_t _i729;
- for (_i729 = 0; _i729 < _size725; ++_i729)
+ uint32_t _size733;
+ ::apache::thrift::protocol::TType _etype736;
+ xfer += iprot->readListBegin(_etype736, _size733);
+ this->component.resize(_size733);
+ uint32_t _i737;
+ for (_i737 = 0; _i737 < _size733; ++_i737)
{
- xfer += this->component[_i729].read(iprot);
+ xfer += this->component[_i737].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17787,10 +18010,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const
xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->component.size()));
- std::vector<LockComponent> ::const_iterator _iter730;
- for (_iter730 = this->component.begin(); _iter730 != this->component.end(); ++_iter730)
+ std::vector<LockComponent> ::const_iterator _iter738;
+ for (_iter738 = this->component.begin(); _iter738 != this->component.end(); ++_iter738)
{
- xfer += (*_iter730).write(oprot);
+ xfer += (*_iter738).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17829,21 +18052,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other731) {
- component = other731.component;
- txnid = other731.txnid;
- user = other731.user;
- hostname = other731.hostname;
- agentInfo = other731.agentInfo;
- __isset = other731.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other732) {
- component = other732.component;
- txnid = other732.txnid;
- user = other732.user;
- hostname = other732.hostname;
- agentInfo = other732.agentInfo;
- __isset = other732.__isset;
+LockRequest::LockRequest(const LockRequest& other739) {
+ component = other739.component;
+ txnid = other739.txnid;
+ user = other739.user;
+ hostname = other739.hostname;
+ agentInfo = other739.agentInfo;
+ __isset = other739.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other740) {
+ component = other740.component;
+ txnid = other740.txnid;
+ user = other740.user;
+ hostname = other740.hostname;
+ agentInfo = other740.agentInfo;
+ __isset = other740.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -17903,9 +18126,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast733;
- xfer += iprot->readI32(ecast733);
- this->state = (LockState::type)ecast733;
+ int32_t ecast741;
+ xfer += iprot->readI32(ecast741);
+ this->state = (LockState::type)ecast741;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -17951,13 +18174,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other734) {
- lockid = other734.lockid;
- state = other734.state;
+LockResponse::LockResponse(const LockResponse& other742) {
+ lockid = other742.lockid;
+ state = other742.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other735) {
- lockid = other735.lockid;
- state = other735.state;
+LockResponse& LockResponse::operator=(const LockResponse& other743) {
+ lockid = other743.lockid;
+ state = other743.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -18079,17 +18302,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other736) {
- lockid = other736.lockid;
- txnid = other736.txnid;
- elapsed_ms = other736.elapsed_ms;
- __isset = other736.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other744) {
+ lockid = other744.lockid;
+ txnid = other744.txnid;
+ elapsed_ms = other744.elapsed_ms;
+ __isset = other744.__isset;
}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other737) {
- lockid = other737.lockid;
- txnid = other737.txnid;
- elapsed_ms = other737.elapsed_ms;
- __isset = other737.__isset;
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other745) {
+ lockid = other745.lockid;
+ txnid = other745.txnid;
+ elapsed_ms = other745.elapsed_ms;
+ __isset = other745.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -18173,11 +18396,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other738) {
- lockid = other738.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other746) {
+ lockid = other746.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other739) {
- lockid = other739.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other747) {
+ lockid = other747.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -18316,19 +18539,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other740) {
- dbname = other740.dbname;
- tablename = other740.tablename;
- partname = other740.partname;
- isExtended = other740.isExtended;
- __isset = other740.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other748) {
+ dbname = other748.dbname;
+ tablename = other748.tablename;
+ partname = other748.partname;
+ isExtended = other748.isExtended;
+ __isset = other748.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other741) {
- dbname = other741.dbname;
- tablename = other741.tablename;
- partname = other741.partname;
- isExtended = other741.isExtended;
- __isset = other741.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other749) {
+ dbname = other749.dbname;
+ tablename = other749.tablename;
+ partname = other749.partname;
+ isExtended = other749.isExtended;
+ __isset = other749.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -18481,9 +18704,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast742;
- xfer += iprot->readI32(ecast742);
- this->state = (LockState::type)ecast742;
+ int32_t ecast750;
+ xfer += iprot->readI32(ecast750);
+ this->state = (LockState::type)ecast750;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -18491,9 +18714,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast743;
- xfer += iprot->readI32(ecast743);
- this->type = (LockType::type)ecast743;
+ int32_t ecast751;
+ xfer += iprot->readI32(ecast751);
+ this->type = (LockType::type)ecast751;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -18709,43 +18932,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other744) {
- lockid = other744.lockid;
- dbname = other744.dbname;
- tablename = other744.tablename;
- partname = other744.partname;
- state = other744.state;
- type = other744.type;
- txnid = other744.txnid;
- lastheartbeat = other744.lastheartbeat;
- acquiredat = other744.acquiredat;
- user = other744.user;
- hostname = other744.hostname;
- heartbeatCount = other744.heartbeatCount;
- agentInfo = other744.agentInfo;
- blockedByExtId = other744.blockedByExtId;
- blockedByIntId = other744.blockedByIntId;
- lockIdInternal = other744.lockIdInternal;
- __isset = other744.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other752) {
+ lockid = other752.lockid;
+ dbname = other752.dbname;
+ tablename = other752.tablename;
+ partname = other752.partname;
+ state = other752.state;
+ type = other752.type;
+ txnid = other752.txnid;
+ lastheartbeat = other752.lastheartbeat;
+ acquiredat = other752.acquiredat;
+ user = other752.user;
+ hostname = other752.hostname;
+ heartbeatCount = other752.heartbeatCount;
+ agentInfo = other752.agentInfo;
+ blockedByExtId = other752.blockedByExtId;
+ blockedByIntId = other752.blockedByIntId;
+ lockIdInternal = other752.lockIdInternal;
+ __isset = other752.__isset;
}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other745) {
- lockid = other745.lockid;
- dbname = other745.dbname;
- tablename = other745.tablename;
- partname = other745.partname;
- state = other745.state;
- type = other745.type;
- txnid = other745.txnid;
- lastheartbeat = other745.lastheartbeat;
- acquiredat = other745.acquiredat;
- user = other745.user;
- hostname = other745.hostname;
- heartbeatCount = other745.heartbeatCount;
- agentInfo = other745.agentInfo;
- blockedByExtId = other745.blockedByExtId;
- blockedByIntId = other745.blockedByIntId;
- lockIdInternal = other745.lockIdInternal;
- __isset = other745.__isset;
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other753) {
+ lockid = other753.lockid;
+ dbname = other753.dbname;
+ tablename = other753.tablename;
+ partname = other753.partname;
+ state = other753.state;
+ type = other753.type;
+ txnid = other753.txnid;
+ lastheartbeat = other753.lastheartbeat;
+ acquiredat = other753.acquiredat;
+ user = other753.user;
+ hostname = other753.hostname;
+ heartbeatCount = other753.heartbeatCount;
+ agentInfo = other753.agentInfo;
+ blockedByExtId = other753.blockedByExtId;
+ blockedByIntId = other753.blockedByIntId;
+ lockIdInternal = other753.lockIdInternal;
+ __isset = other753.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -18804,14 +19027,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size746;
- ::apache::thrift::protocol::TType _etype749;
- xfer += iprot->readListBegin(_etype749, _size746);
- this->locks.resize(_size746);
- uint32_t _i750;
- for (_i750 = 0; _i750 < _size746; ++_i750)
+ uint32_t _size754;
+ ::apache::thrift::protocol::TType _etype757;
+ xfer += iprot->readListBegin(_etype757, _size754);
+ this->locks.resize(_size754);
+ uint32_t _i758;
+ for (_i758 = 0; _i758 < _size754; ++_i758)
{
- xfer += this->locks[_i750].read(iprot);
+ xfer += this->locks[_i758].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -18840,10 +19063,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->locks.size()));
- std::vector<ShowLocksResponseElement> ::const_iterator _iter751;
- for (_iter751 = this->locks.begin(); _iter751 != this->locks.end(); ++_iter751)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter759;
+ for (_iter759 = this->locks.begin(); _iter759 != this->locks.end(); ++_iter759)
{
- xfer += (*_iter751).write(oprot);
+ xfer += (*_iter759).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -18860,13 +19083,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other752) {
- locks = other752.locks;
- __isset = other752.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other760) {
+ locks = other760.locks;
+ __isset = other760.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other753) {
- locks = other753.locks;
- __isset = other753.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other761) {
+ locks = other761.locks;
+ __isset = other761.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -18967,15 +19190,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other754) {
- lockid = other754.lockid;
- txnid = other754.txnid;
- __isset = other754.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other762) {
+ lockid = other762.lockid;
+ txnid = other762.txnid;
+ __isset = other762.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other755) {
- lockid = other755.lockid;
- txnid = other755.txnid;
- __isset = other755.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other763) {
+ lockid = other763.lockid;
+ txnid = other763.txnid;
+ __isset = other763.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -19078,13 +19301,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other756) {
- min = other756.min;
- max = other756.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other764) {
+ min = other764.min;
+ max = other764.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other757) {
- min = other757.min;
- max = other757.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other765) {
+ min = other765.min;
+ max = other765.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -19135,15 +19358,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size758;
- ::apache::thrift::protocol::TType _etype761;
- xfer += iprot->readSetBegin(_etype761, _size758);
- uint32_t _i762;
- for (_i762 = 0; _i762 < _size758; ++_i762)
+ uint32_t _size766;
+ ::apache::thrift::protocol::TType _etype769;
+ xfer += iprot->readSetBegin(_etype769, _size766);
+ uint32_t _i770;
+ for (_i770 = 0; _i770 < _size766; ++_i770)
{
- int64_t _elem763;
- xfer += iprot->readI64(_elem763);
- this->aborted.insert(_elem763);
+ int64_t _elem771;
+ xfer += iprot->readI64(_elem771);
+ this->aborted.insert(_elem771);
}
xfer += iprot->readSetEnd();
}
@@ -19156,15 +19379,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size764;
- ::apache::thrift::protocol::TType _etype767;
- xfer += iprot->readSetBegin(_etype767, _size764);
- uint32_t _i768;
- for (_i768 = 0; _i768 < _size764; ++_i768)
+ uint32_t _size772;
+ ::apache::thrift::protocol::TType _etype775;
+ xfer += iprot->readSetBegin(_etype775, _size772);
+ uint32_t _i776;
+ for (_i776 = 0; _i776 < _size772; ++_i776)
{
- int64_t _elem769;
- xfer += iprot->readI64(_elem769);
- this->nosuch.insert(_elem769);
+ int64_t _elem777;
+ xfer += iprot->readI64(_elem777);
+ this->nosuch.insert(_elem777);
}
xfer += iprot->readSetEnd();
}
@@ -19197,10 +19420,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->aborted.size()));
- std::set<int64_t> ::const_iterator _iter770;
- for (_iter770 = this->aborted.begin(); _iter770 != this->aborted.end(); ++_iter770)
+ std::set<int64_t> ::const_iterator _iter778;
+ for (_iter778 = this->aborted.begin(); _iter778 != this->aborted.end(); ++_iter778)
{
- xfer += oprot->writeI64((*_iter770));
+ xfer += oprot->writeI64((*_iter778));
}
xfer += oprot->writeSetEnd();
}
@@ -19209,10 +19432,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->nosuch.size()));
- std::set<int64_t> ::const_iterator _iter771;
- for (_iter771 = this->nosuch.begin(); _iter771 != this->nosuch.end(); ++_iter771)
+ std::set<int64_t> ::const_iterator _iter779;
+ for (_iter779 = this->nosuch.begin(); _iter779 != this->nosuch.end(); ++_iter779)
{
- xfer += oprot->writeI64((*_iter771));
+ xfer += oprot->writeI64((*_iter779));
}
xfer += oprot->writeSetEnd();
}
@@ -19229,13 +19452,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other772) {
- aborted = other772.aborted;
- nosuch = other772.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other780) {
+ aborted = other780.aborted;
+ nosuch = other780.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other773) {
- aborted = other773.aborted;
- nosuch = other773.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other781) {
+ aborted = other781.aborted;
+ nosuch = other781.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -19328,9 +19551,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast774;
- xfer += iprot->readI32(ecast774);
- this->type = (CompactionType::type)ecast774;
+ int32_t ecast782;
+ xfer += iprot->readI32(ecast782);
+ this->type = (CompactionType::type)ecast782;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -19348,17 +19571,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size775;
- ::apache::thrift::protocol::TType _ktype776;
- ::apache::thrift::protocol::TType _vtype777;
- xfer += iprot->readMapBegin(_ktype776, _vtype777, _size775);
- uint32_t _i779;
- for (_i779 = 0; _i779 < _size775; ++_i779)
+ uint32_t _size783;
+ ::apache::thrift::protocol::TType _ktype784;
+ ::apache::thrift::protocol::TType _vtype785;
+ xfer += iprot->readMapBegin(_ktype784, _vtype785, _size783);
+ uint32_t _i787;
+ for (_i787 = 0; _i787 < _size783; ++_i787)
{
- std::string _key780;
- xfer += iprot->readString(_key780);
- std::string& _val781 = this->properties[_key780];
- xfer += iprot->readString(_val781);
+ std::string _key788;
+ xfer += iprot->readString(_key788);
+ std::string& _val789 = this->properties[_key788];
+ xfer += iprot->readString(_val789);
}
xfer += iprot->readMapEnd();
}
@@ -19416,11 +19639,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size()));
- std::map<std::string, std::string> ::const_iterator _iter782;
- for (_iter782 = this->properties.begin(); _iter782 != this->properties.end(); ++_iter782)
+ std::map<std::string, std::string> ::const_iterator _iter790;
+ for (_iter790 = this->properties.begin(); _iter790 != this->properties.end(); ++_iter790)
{
- xfer += oprot->writeString(_iter782->first);
- xfer += oprot->writeString(_iter782->second);
+ xfer += oprot->writeString(_iter790->first);
+ xfer += oprot->writeString(_iter790->second);
}
xfer += oprot->writeMapEnd();
}
@@ -19442,23 +19665,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other783) {
- dbname = other783.dbname;
- tablename = other783.tablename;
- partitionname = other783.partitionname;
- type = other783.type;
- runas = other783.runas;
- properties = other783.properties;
- __isset = other783.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other784) {
- dbname = other784.dbname;
- tablename = other784.tablename;
- partitionname = other784.partitionname;
- type = other784.type;
- runas = other784.runas;
- properties = other784.properties;
- __isset = other784.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other791) {
+ dbname = other791.dbname;
+ tablename = other791.tablename;
+ partitionname = other791.partitionname;
+ type = other791.type;
+ runas = other791.runas;
+ properties = other791.properties;
+ __isset = other791.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other792) {
+ dbname = other792.dbname;
+ tablename = other792.tablename;
+ partitionname = other792.partitionname;
+ type = other792.type;
+ runas = other792.runas;
+ properties = other792.properties;
+ __isset = other792.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -19585,15 +19808,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) {
swap(a.accepted, b.accepted);
}
-CompactionResponse::CompactionResponse(const CompactionResponse& other785) {
- id = other785.id;
- state = other785.state;
- accepted = other785.accepted;
+CompactionResponse::CompactionResponse(const CompactionResponse& other793) {
+ id = other793.id;
+ state = other793.state;
+ accepted = other793.accepted;
}
-CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other786) {
- id = other786.id;
- state = other786.state;
- accepted = other786.accepted;
+CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other794) {
+ id = other794.id;
+ state = other794.state;
+ accepted = other794.accepted;
return *this;
}
void CompactionResponse::printTo(std::ostream& out) const {
@@ -19654,11 +19877,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other787) {
- (void) other787;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other795) {
+ (void) other795;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other788) {
- (void) other788;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other796) {
+ (void) other796;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -19784,9 +20007,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast789;
- xfer += iprot->readI32(ecast789);
- this->type = (CompactionType::type)ecast789;
+ int32_t ecast797;
+ xfer += iprot->readI32(ecast797);
+ this->type = (CompactionType::type)ecast797;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -19973,37 +20196,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other790) {
- dbname = other790.dbname;
- tablename = other790.tablename;
- partitionname = other790.partitionname;
- type = other790.type;
- state = other790.state;
- workerid = other790.workerid;
- start = other790.start;
- runAs = other790.runAs;
- hightestTxnId = other790.hightestTxnId;
- metaInfo = other790.metaInfo;
- endTime = other790.endTime;
- hadoopJobId = other790.hadoopJobId;
- id = other790.id;
- __isset = other790.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other791) {
- dbname = other791.dbname;
- tablename = other791.tablename;
- partitionname = other791.partitionname;
- type = other791.type;
- state = other791.state;
- workerid = other791.workerid;
- start = other791.start;
- runAs = other791.runAs;
- hightestTxnId = other791.hightestTxnId;
- metaInfo = other791.metaInfo;
- endTime = other791.endTime;
- hadoopJobId = other791.hadoopJobId;
- id = other791.id;
- __isset = other791.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other798) {
+ dbname = other798.dbname;
+ tablename = other798.tablename;
+ partitionname = other798.partitionname;
+ type = other798.type;
+ state = other798.state;
+ workerid = other798.workerid;
+ start = other798.start;
+ runAs = other798.runAs;
+ hightestTxnId = other798.hightestTxnId;
+ metaInfo = other798.metaInfo;
+ endTime = other798.endTime;
+ hadoopJobId = other798.hadoopJobId;
+ id = other798.id;
+ __isset = other798.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other799) {
+ dbname = other799.dbname;
+ tablename = other799.tablename;
+ partitionname = other799.partitionname;
+ type = other799.type;
+ state = other799.state;
+ workerid = other799.workerid;
+ start = other799.start;
+ runAs = other799.runAs;
+ hightestTxnId = other799.hightestTxnId;
+ metaInfo = other799.metaInfo;
+ endTime = other799.endTime;
+ hadoopJobId = other799.hadoopJobId;
+ id = other799.id;
+ __isset = other799.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -20060,14 +20283,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size792;
- ::apache::thrift::protocol::TType _etype795;
- xfer += iprot->readListBegin(_etype795, _size792);
- this->compacts.resize(_size792);
- uint32_t _i796;
- for (_i796 = 0; _i796 < _size792; ++_i796)
+ uint32_t _size800;
+ ::apache::thrift::protocol::TType _etype803;
+ xfer += iprot->readListBegin(_etype803, _size800);
+ this->compacts.resize(_size800);
+ uint32_t _i804;
+ for (_i804 = 0; _i804 < _size800; ++_i804)
{
- xfer += this->compacts[_i796].read(iprot);
+ xfer += this->compacts[_i804].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -20098,10 +20321,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->compacts.size()));
- std::vector<ShowCompactResponseElement> ::const_iterator _iter797;
- for (_iter797 = this->compacts.begin(); _iter797 != this->compacts.end(); ++_iter797)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter805;
+ for (_iter805 = this->compacts.begin(); _iter805 != this->compacts.end(); ++_iter805)
{
- xfer += (*_iter797).write(oprot);
+ xfer += (*_iter805).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -20117,11 +20340,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other798) {
- compacts = other798.compacts;
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other806) {
+ compacts = other806.compacts;
}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other799) {
- compacts = other799.compacts;
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other807) {
+ compacts = other807.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -20223,14 +20446,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- uint32_t _size800;
- ::apache::thrift::protocol::TType _etype803;
- xfer += iprot->readListBegin(_etype803, _size800);
- this->partitionnames.resize(_size800);
- uint32_t _i804;
- for (_i804 = 0; _i804 < _size800; ++_i804)
+ uint32_t _size808;
+ ::apache::thrift::protocol::TType _etype811;
+ xfer += iprot->readListBegin(_etype811, _size808);
+ this->partitionnames.resize(_size808);
+ uint32_t _i812;
+ for (_i812 = 0; _i812 < _size808; ++_i812)
{
- xfer += iprot->readString(this->partitionnames[_i804]);
+ xfer += iprot->readString(this->partitionnames[_i812]);
}
xfer += iprot->readListEnd();
}
@@ -20241,9 +20464,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast805;
- xfer += iprot->readI32(ecast805);
- this->operationType = (DataOperationType::type)ecast805;
+ int32_t ecast813;
+ xfer += iprot->readI32(ecast813);
+ this->operationType = (DataOperationType::type)ecast813;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -20295,10 +20518,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionnames.size()));
- std::vector<std::string> ::const_iterator _iter806;
- for (_iter806 = this->partitionnames.begin(); _iter806 != this->partitionnames.end(); ++_iter806)
+ std::vector<std::string> ::const_iterator _iter814;
+ for (_iter814 = this->partitionnames.begin(); _iter814 != this->partitionnames.end(); ++_iter814)
{
- xfer += oprot->writeString((*_iter806));
+ xfer += oprot->writeString((*_iter814));
}
xfer += oprot->writeListEnd();
}
@@ -20325,23 +20548,23 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.__isset, b.__isset);
}
-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other807) {
- txnid = other807.txnid;
- writeid = other807.writeid;
- dbname = other807.dbname;
- tablename = other807.tablename;
- partitionnames = other807.partitionnames;
- operationType = other807.operationType;
- __isset = other807.__isset;
-}
-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other808) {
- txnid = other808.txnid;
- writeid = other808.writeid;
- dbname = other808.dbname;
- tablename = other808.tablename;
- partitionnames = other808.partitionnames;
- operationType = other808.operationType;
- __isset = other808.__isset;
+AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other815) {
+ txnid = other815.txnid;
+ writeid = other815.writeid;
+ dbname = other815.dbname;
+ tablename = other815.tablename;
+ partitionnames = other815.partitionnames;
+ operationType = other815.operationType;
+ __isset = other815.__isset;
+}
+AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other816) {
+ txnid = other816.txnid;
+ writeid = other816.writeid;
+ dbname = other816.dbname;
+ tablename = other816.tablename;
+ partitionnames = other816.partitionnames;
+ operationType = other816.operationType;
+ __isset = other816.__isset;
return *this;
}
void AddDynamicPartitions::printTo(std::ostream& out) const {
@@ -20524,23 +20747,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) {
swap(a.__isset, b.__isset);
}
-BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other809) {
- isnull = other809.isnull;
- time = other809.time;
- txnid = other809.txnid;
- dbname = other809.dbname;
- tablename = other809.tablename;
- partitionname = other809.partitionname;
- __isset = other809.__isset;
-}
-BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other810) {
- isnull = other810.isnull;
- time = other810.time;
- txnid = other810.txnid;
- dbname = other810.dbname;
- tablename = other810.tablename;
- partitionname = other810.partitionname;
- __isset = other810.__isset;
+BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other817) {
+ isnull = other817.isnull;
+ time = other817.time;
+ txnid = other817.txnid;
+ dbname = other817.dbname;
+ tablename = other817.tablename;
+ partitionname = other817.partitionname;
+ __isset = other817.__isset;
+}
+BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other818) {
+ isnull = other818.isnull;
+ time = other818.time;
+ txnid = other818.txnid;
+ dbname = other818.dbname;
+ tablename = other818.tablename;
+ partitionname = other818.partitionname;
+ __isset = other818.__isset;
return *this;
}
void BasicTxnInfo::printTo(std::ostream& out) const {
@@ -20634,15 +20857,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->tablesUsed.clear();
- uint32_t _size811;
- ::apache::thrift::protocol::TType _etype814;
- xfer += iprot->readSetBegin(_etype814, _size811);
- uint32_t _i815;
- for (_i815 = 0; _i815 < _size811; ++_i815)
+ uint32_t _size819;
+ ::apache::thrift::protocol::TType _etype822;
+ xfer += iprot->readSetBegin(_etype822, _size819);
+ uint32_t _i823;
+ for (_i823 = 0; _i823 < _size819; ++_i823)
{
- std::string _elem816;
- xfer += iprot->readString(_elem816);
- this->tablesUsed.insert(_elem816);
+ std::string _elem824;
+ xfer += iprot->readString(_elem824);
+ this->tablesUsed.insert(_elem824);
}
xfer += iprot->readSetEnd();
}
@@ -20699,10 +20922,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 4);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tablesUsed.size()));
- std::set<std::string> ::const_iterator _iter817;
- for (_iter817 = this->tablesUsed.begin(); _iter817 != this->tablesUsed.end(); ++_iter817)
+ std::set<std::string> ::const_iterator _iter825;
+ for (_iter825 = this->tablesUsed.begin(); _iter825 != this->tablesUsed.end(); ++_iter825)
{
- xfer += oprot->writeString((*_iter817));
+ xfer += oprot->writeString((*_iter825));
}
xfer += oprot->writeSetEnd();
}
@@ -20728,21 +20951,21 @@ void swap(CreationMetadata &a, CreationMetadata &b) {
swap(a.__isset, b.__isset);
}
-CreationMetadata::CreationMetadata(const CreationMetadata& other818) {
- catName = other818.catName;
- dbName = other818.dbName;
- tblName = other818.tblName;
- tablesUsed = other818.tablesUsed;
- validTxnList = other818.validTxnList;
- __isset = other818.__isset;
-}
-CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other819) {
- catName = other819.catName;
- dbName = other819.dbName;
- tblName = other819.tblName;
- tablesUsed = other819.tablesUsed;
- validTxnList = other819.validTxnList;
- __isset = other819.__isset;
+CreationMetadata::CreationMetadata(const CreationMetadata& other826) {
+ catName = other826.catName;
+ dbName = other826.dbName;
+ tblName = other826.tblName;
+ tablesUsed = other826.tablesUsed;
+ validTxnList = other826.validTxnList;
+ __isset = other826.__isset;
+}
+CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other827) {
+ catName = other827.catName;
+ dbName = other827.dbName;
+ tblName = other827.tblName;
+ tablesUsed = other827.tablesUsed;
+ validTxnList = other827.validTxnList;
+ __isset = other827.__isset;
return *this;
}
void CreationMetadata::printTo(std::ostream& out) const {
@@ -20848,15 +21071,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other820) {
- lastEvent = other820.lastEvent;
- maxEvents = other820.maxEvents;
- __isset = other820.__isset;
+NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other828) {
+ lastEvent = other828.lastEvent;
+ maxEvents = other828.maxEvents;
+ __isset = other828.__isset;
}
-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other821) {
- lastEvent = other821.lastEvent;
- maxEvents = other821.maxEvents;
- __isset = other821.__isset;
+NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other829) {
+ lastEvent = other829.lastEvent;
+ maxEvents = other829.maxEvents;
+ __isset = other829.__isset;
return *this;
}
void NotificationEventRequest::printTo(std::ostream& out) const {
@@ -21076,27 +21299,27 @@ void swap(NotificationEvent &a, NotificationEvent &b) {
swap(a.__isset, b.__isset);
}
-NotificationEvent::NotificationEvent(const NotificationEvent& other822) {
- eventId = other822.eventId;
- eventTime = other822.eventTime;
- eventType = other822.eventType;
- dbName = other822.dbName;
- tableName = other822.tableName;
- message = other822.message;
- messageFormat = other822.messageFormat;
- catName = other822.catName;
- __isset = other822.__isset;
-}
-NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other823) {
- eventId = other823.eventId;
- eventTime = other823.eventTime;
- eventType = other823.eventType;
- dbName = other823.dbName;
- tableName = other823.tableName;
- message = other823.message;
- messageFormat = other823.messageFormat;
- catName = other823.catName;
- __isset = other823.__isset;
+NotificationEvent::NotificationEvent(const NotificationEvent& other830) {
+ eventId = other830.eventId;
+ eventTime = other830.eventTime;
+ eventType = other830.eventType;
+ dbName = other830.dbName;
+ tableName = other830.tableName;
+ message = other830.message;
+ messageFormat = other830.messageFormat;
+ catName = other830.catName;
+ __isset = other830.__isset;
+}
+NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other831) {
+ eventId = other831.eventId;
+ eventTime = other831.eventTime;
+ eventType = other831.eventType;
+ dbName = other831.dbName;
+ tableName = other831.tableName;
+ message = other831.message;
+ messageFormat = other831.messageFormat;
+ catName = other831.catName;
+ __isset = other831.__isset;
return *this;
}
void NotificationEvent::printTo(std::ostream& out) const {
@@ -21148,14 +21371,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->events.clear();
- uint32_t _size824;
- ::apache::thrift::protocol::TType _etype827;
- xfer += iprot->readListBegin(_etype827, _size824);
- this->events.resize(_size824);
- uint32_t _i828;
- for (_i828 = 0; _i828 < _size824; ++_i828)
+ uint32_t _size832;
+ ::apache::thrift::protocol::TType _etype835;
+ xfer += iprot->readListBegin(_etype835, _size832);
+ this->events.resize(_size832);
+ uint32_t _i836;
+ for (_i836 = 0; _i836 < _size832; ++_i836)
{
- xfer += this->events[_i828].read(iprot);
+ xfer += this->events[_i836].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -21186,10 +21409,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol*
xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->events.size()));
- std::vector<NotificationEvent> ::const_iterator _iter829;
- for (_iter829 = this->events.begin(); _iter829 != this->events.end(); ++_iter829)
+ std::vector<NotificationEvent> ::const_iterator _iter837;
+ for (_iter837 = this->events.begin(); _iter837 != this->events.end(); ++_iter837)
{
- xfer += (*_iter829).write(oprot);
+ xfer += (*_iter837).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -21205,11 +21428,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
swap(a.events, b.events);
}
-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other830) {
- events = other830.events;
+NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other838) {
+ events = other838.events;
}
-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other831) {
- events = other831.events;
+NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other839) {
+ events = other839.events;
return *this;
}
void NotificationEventResponse::printTo(std::ostream& out) const {
@@ -21291,11 +21514,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
swap(a.eventId, b.eventId);
}
-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other832) {
- eventId = other832.eventId;
+CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other840) {
+ eventId = other840.eventId;
}
-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other833) {
- eventId = other833.eventId;
+CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other841) {
+ eventId = other841.eventId;
return *this;
}
void CurrentNotificationEventId::printTo(std::ostream& out) const {
@@ -21417,17 +21640,17 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b)
swap(a.__isset, b.__isset);
}
-NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other834) {
- fromEventId = other834.fromEventId;
- dbName = other834.dbName;
- catName = other834.catName;
- __isset = other834.__isset;
+NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other842) {
+ fromEventId = other842.fromEventId;
+ dbName = other842.dbName;
+ catName = other842.catName;
+ __isset = other842.__isset;
}
-NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other835) {
- fromEventId = other835.fromEventId;
- dbName = other835.dbName;
- catName = other835.catName;
- __isset = other835.__isset;
+NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other843) {
+ fromEventId = other843.fromEventId;
+ dbName = other843.dbName;
+ catName = other843.catName;
+ __isset = other843.__isset;
return *this;
}
void NotificationEventsCountRequest::printTo(std::ostream& out) const {
@@ -21511,11 +21734,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b
swap(a.eventsCount, b.eventsCount);
}
-NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other836) {
- eventsCount = other836.eventsCount;
+NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other844) {
+ eventsCount = other844.eventsCount;
}
-NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other837) {
- eventsCount = other837.eventsCount;
+NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other845) {
+ eventsCount = other845.eventsCount;
return *this;
}
void NotificationEventsCountResponse::printTo(std::ostream& out) const {
@@ -21578,14 +21801,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAdded.clear();
- uint32_t _size838;
- ::apache::thrift::protocol::TType _etype841;
- xfer += iprot->readListBegin(_etype841, _size838);
- this->filesAdded.resize(_size838);
- uint32_t _i842;
- for (_i842 = 0; _i842 < _size838; ++_i842)
+ uint32_t _size846;
+ ::apache::thrift::protocol::TType _etype849;
+ xfer += iprot->readListBegin(_etype849, _size846);
+ this->filesAdded.resize(_size846);
+ uint32_t _i850;
+ for (_i850 = 0; _i850 < _size846; ++_i850)
{
- xfer += iprot->readString(this->filesAdded[_i842]);
+ xfer += iprot->readString(this->filesAdded[_i850]);
}
xfer += iprot->readListEnd();
}
@@ -21598,14 +21821,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAddedChecksum.clear();
- uint32_t _size843;
- ::apache::thrift::protocol::TType _etype846;
- xfer += iprot->readListBegin(_etype846, _size843);
- this->filesAddedChecksum.resize(_size843);
- uint32_t _i847;
- for (_i847 = 0; _i847 < _size843; ++_i847)
+ uint32_t _size851;
+ ::apache::thrift::protocol::TType _etype854;
+ xfer += iprot->readListBegin(_etype854, _size851);
+ this->filesAddedChecksum.resize(_size851);
+ uint32_t _i855;
+ for (_i855 = 0; _i855 < _size851; ++_i855)
{
- xfer += iprot->readString(this->filesAddedChecksum[_i847]);
+ xfer += iprot->readString(this->filesAddedChecksum[_i855]);
}
xfer += iprot->readListEnd();
}
@@ -21641,10 +21864,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size()));
- std::vector<std::string> ::const_iterator _iter848;
- for (_iter848 = this->filesAdded.begin(); _iter848 != this->filesAdded.end(); ++_iter848)
+ std::vector<std::string> ::const_iterator _iter856;
+ for (_iter856 = this->filesAdded.begin(); _iter856 != this->filesAdded.end(); ++_iter856)
{
- xfer += oprot->writeString((*_iter848));
+ xfer += oprot->writeString((*_iter856));
}
xfer += oprot->writeListEnd();
}
@@ -21654,10 +21877,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size()));
- std::vector<std::string> ::const_iterator _iter849;
- for (_iter849 = this->filesAddedChecksum.begin(); _iter849 != this->filesAddedChecksum.end(); ++_iter849)
+ std::vector<std::string> ::const_iterator _iter857;
+ for (_iter857 = this->filesAddedChecksum.begin(); _iter857 != this->filesAddedChecksum.end(); ++_iter857)
{
- xfer += oprot->writeString((*_iter849));
+ xfer += oprot->writeString((*_iter857));
}
xfer += oprot->writeListEnd();
}
@@ -21676,17 +21899,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other850) {
- replace = other850.replace;
- filesAdded = other850.filesAdded;
- filesAddedChecksum = other850.filesAddedChecksum;
- __isset = other850.__isset;
+InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other858) {
+ replace = other858.replace;
+ filesAdded = other858.filesAdded;
+ filesAddedChecksum = other858.filesAddedChecksum;
+ __isset = other858.__isset;
}
-InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other851) {
- replace = other851.replace;
- filesAdded = other851.filesAdded;
- filesAddedChecksum = other851.filesAddedChecksum;
- __isset = other851.__isset;
+InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other859) {
+ replace = other859.replace;
+ filesAdded = other859.filesAdded;
+ filesAddedChecksum = other859.filesAddedChecksum;
+ __isset = other859.__isset;
return *this;
}
void InsertEventRequestData::printTo(std::ostream& out) const {
@@ -21768,13 +21991,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequestData::FireEventRequestData(const FireEventRequestData& other852) {
- insertData = other852.insertData;
- __isset = other852.__isset;
+FireEventRequestData::FireEventRequestData(const FireEventRequestData& other860) {
+ insertData = other860.insertData;
+ __isset = other860.__isset;
}
-FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other853) {
- insertData = other853.insertData;
- __isset = other853.__isset;
+FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other861) {
+ insertData = other861.insertData;
+ __isset = other861.__isset;
return *this;
}
void FireEventRequestData::printTo(std::ostream& out) const {
@@ -21876,14 +22099,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionVals.clear();
- uint32_t _size854;
- ::apache::thrift::protocol::TType _etype857;
- xfer += iprot->readListBegin(_etype857, _size854);
- this->partitionVals.resize(_size854);
- uint32_t _i858;
- for (_i858 = 0; _i858 < _size854; ++_i858)
+ uint32_t _size862;
+ ::apache::thrift::protocol::TType _etype865;
+ xfer += iprot->readListBegin(_etype865, _size862);
+ this->partitionVals.resize(_size862);
+ uint32_t _i866;
+ for (_i866 = 0; _i866 < _size862; ++_i866)
{
- xfer += iprot->readString(this->partitionVals[_i858]);
+ xfer += iprot->readString(this->partitionVals[_i866]);
}
xfer += iprot->readListEnd();
}
@@ -21943,10 +22166,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionVals.size()));
- std::vector<std::string> ::const_iterator _iter859;
- for (_iter859 = this->partitionVals.begin(); _iter859 != this->partitionVals.end(); ++_iter859)
+ std::vector<std::string> ::const_iterator _iter867;
+ for (_iter867 = this->partitionVals.begin(); _iter867 != this->partitionVals.end(); ++_iter867)
{
- xfer += oprot->writeString((*_iter859));
+ xfer += oprot->writeString((*_iter867));
}
xfer += oprot->writeListEnd();
}
@@ -21973,23 +22196,23 @@ void swap(FireEventRequest &a, FireEventRequest &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequest::FireEventRequest(const FireEventRequest& other860) {
- successful = other860.successful;
- data = other860.data;
- dbName = other860.dbName;
- tableName = other860.tableName;
- partitionVals = other860.partitionVals;
- catName = other860.catName;
- __isset = other860.__isset;
-}
-FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other861) {
- successful = other861.successful;
- data = other861.data;
- dbName = other861.dbName;
- tableName = other861.tableName;
- partitionVals = other861.partitionVals;
- catName = other861.catName;
- __isset = other861.__isset;
+FireEventRequest::FireEventRequest(const FireEventRequest& other868) {
+ successful = other868.successful;
+ data = other868.data;
+ dbName = other868.dbName;
+ tableName = other868.tableName;
+ partitionVals = other868.partitionVals;
+ catName = other868.catName;
+ __isset = other868.__isset;
+}
+FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other869) {
+ successful = other869.successful;
+ data = other869.data;
+ dbName = other869.dbName;
+ tableName = other869.tableName;
+ partitionVals = other869.partitionVals;
+ catName = other869.catName;
+ __isset = other869.__isset;
return *this;
}
void FireEventRequest::printTo(std::ostream& out) const {
@@ -22053,11 +22276,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) {
(void) b;
}
-FireEventResponse::FireEventResponse(const FireEventResponse& other862) {
- (void) other862;
+FireEventResponse::FireEventResponse(const FireEventResponse& other870) {
+ (void) other870;
}
-FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other863) {
- (void) other863;
+FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other871) {
+ (void) other871;
return *this;
}
void FireEventResponse::printTo(std::ostream& out) const {
@@ -22157,15 +22380,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) {
swap(a.__isset, b.__isset);
}
-MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other864) {
- metadata = other864.metadata;
- includeBitset = other864.includeBitset;
- __isset = other864.__isset;
+MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other872) {
+ metadata = other872.metadata;
+ includeBitset = other872.includeBitset;
+ __isset = other872.__isset;
}
-MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other865) {
- metadata = other865.metadata;
- includeBitset = other865.includeBitset;
- __isset = other865.__isset;
+MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other873) {
+ metadata = other873.metadata;
+ includeBitset = other873.includeBitset;
+ __isset = other873.__isset;
return *this;
}
void MetadataPpdResult::printTo(std::ostream& out) const {
@@ -22216,17 +22439,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->metadata.clear();
- uint32_t _size866;
- ::apache::thrift::protocol::TType _ktype867;
- ::apache::thrift::protocol::TType _vtype868;
- xfer += iprot->readMapBegin(_ktype867, _vtype868, _size866);
- uint32_t _i870;
- for (_i870 = 0; _i870 < _size866; ++_i870)
+ uint32_t _size874;
+ ::apache::thrift::protocol::TType _ktype875;
+ ::apache::thrift::protocol::TType _vtype876;
+ xfer += iprot->readMapBegin(_ktype875, _vtype876, _size874);
+ uint32_t _i878;
+ for (_i878 = 0; _i878 < _size874; ++_i878)
{
- int64_t _key871;
- xfer += iprot->readI64(_key871);
- MetadataPpdResult& _val872 = this->metadata[_key871];
- xfer += _val872.read(iprot);
+ int64_t _key879;
+ xfer += iprot->readI64(_key879);
+ MetadataPpdResult& _val880 = this->metadata[_key879];
+ xfer += _val880.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -22267,11 +22490,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco
xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->metadata.size()));
- std::map<int64_t, MetadataPpdResult> ::const_iterator _iter873;
- for (_iter873 = this->metadata.begin(); _iter873 != this->metadata.end(); ++_iter873)
+ std::map<int64_t, MetadataPpdResult> ::const_iterator _iter881;
+ for (_iter881 = this->metadata.begin(); _iter881 != this->metadata.end(); ++_iter881)
{
- xfer += oprot->writeI64(_iter873->first);
- xfer += _iter873->second.write(oprot);
+ xfer += oprot->writeI64(_iter881->first);
+ xfer += _iter881->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -22292,13 +22515,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) {
swap(a.isSupported, b.isSupported);
}
-GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other874) {
- metadata = other874.metadata;
- isSupported = other874.isSupported;
+GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other882) {
+ metadata = other882.metadata;
+ isSupported
<TRUNCATED>