You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by sa...@apache.org on 2018/07/03 10:02:51 UTC
[12/16] hive git commit: HIVE-19267: Replicate ACID/MM tables write
operations (Mahesh Kumar Behera, reviewed by Sankar Hariappan)
http://git-wip-us.apache.org/repos/asf/hive/blob/f519db7e/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 bc4d168..7f06b3b 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
@@ -16592,6 +16592,11 @@ void CommitTxnRequest::__set_replPolicy(const std::string& val) {
__isset.replPolicy = true;
}
+void CommitTxnRequest::__set_writeEventInfos(const std::vector<WriteEventInfo> & val) {
+ this->writeEventInfos = val;
+__isset.writeEventInfos = true;
+}
+
uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@ -16630,6 +16635,26 @@ uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
xfer += iprot->skip(ftype);
}
break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->writeEventInfos.clear();
+ uint32_t _size673;
+ ::apache::thrift::protocol::TType _etype676;
+ xfer += iprot->readListBegin(_etype676, _size673);
+ this->writeEventInfos.resize(_size673);
+ uint32_t _i677;
+ for (_i677 = 0; _i677 < _size673; ++_i677)
+ {
+ xfer += this->writeEventInfos[_i677].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.writeEventInfos = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -16658,6 +16683,19 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeString(this->replPolicy);
xfer += oprot->writeFieldEnd();
}
+ if (this->__isset.writeEventInfos) {
+ xfer += oprot->writeFieldBegin("writeEventInfos", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->writeEventInfos.size()));
+ std::vector<WriteEventInfo> ::const_iterator _iter678;
+ for (_iter678 = this->writeEventInfos.begin(); _iter678 != this->writeEventInfos.end(); ++_iter678)
+ {
+ xfer += (*_iter678).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
xfer += oprot->writeFieldStop();
xfer += oprot->writeStructEnd();
return xfer;
@@ -16667,18 +16705,21 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
using ::std::swap;
swap(a.txnid, b.txnid);
swap(a.replPolicy, b.replPolicy);
+ swap(a.writeEventInfos, b.writeEventInfos);
swap(a.__isset, b.__isset);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other673) {
- txnid = other673.txnid;
- replPolicy = other673.replPolicy;
- __isset = other673.__isset;
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other679) {
+ txnid = other679.txnid;
+ replPolicy = other679.replPolicy;
+ writeEventInfos = other679.writeEventInfos;
+ __isset = other679.__isset;
}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other674) {
- txnid = other674.txnid;
- replPolicy = other674.replPolicy;
- __isset = other674.__isset;
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other680) {
+ txnid = other680.txnid;
+ replPolicy = other680.replPolicy;
+ writeEventInfos = other680.writeEventInfos;
+ __isset = other680.__isset;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -16686,6 +16727,231 @@ void CommitTxnRequest::printTo(std::ostream& out) const {
out << "CommitTxnRequest(";
out << "txnid=" << to_string(txnid);
out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "<null>"));
+ out << ", " << "writeEventInfos="; (__isset.writeEventInfos ? (out << to_string(writeEventInfos)) : (out << "<null>"));
+ out << ")";
+}
+
+
+WriteEventInfo::~WriteEventInfo() throw() {
+}
+
+
+void WriteEventInfo::__set_writeId(const int64_t val) {
+ this->writeId = val;
+}
+
+void WriteEventInfo::__set_database(const std::string& val) {
+ this->database = val;
+}
+
+void WriteEventInfo::__set_table(const std::string& val) {
+ this->table = val;
+}
+
+void WriteEventInfo::__set_files(const std::string& val) {
+ this->files = val;
+}
+
+void WriteEventInfo::__set_partition(const std::string& val) {
+ this->partition = val;
+__isset.partition = true;
+}
+
+void WriteEventInfo::__set_tableObj(const std::string& val) {
+ this->tableObj = val;
+__isset.tableObj = true;
+}
+
+void WriteEventInfo::__set_partitionObj(const std::string& val) {
+ this->partitionObj = val;
+__isset.partitionObj = true;
+}
+
+uint32_t WriteEventInfo::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_writeId = false;
+ bool isset_database = false;
+ bool isset_table = false;
+ bool isset_files = 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->writeId);
+ isset_writeId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->database);
+ isset_database = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->table);
+ isset_table = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->files);
+ isset_files = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->partition);
+ this->__isset.partition = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tableObj);
+ this->__isset.tableObj = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->partitionObj);
+ this->__isset.partitionObj = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_writeId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_database)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_table)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_files)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t WriteEventInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("WriteEventInfo");
+
+ xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->writeId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("database", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->database);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->table);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("files", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->files);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.partition) {
+ xfer += oprot->writeFieldBegin("partition", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->partition);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.tableObj) {
+ xfer += oprot->writeFieldBegin("tableObj", ::apache::thrift::protocol::T_STRING, 6);
+ xfer += oprot->writeString(this->tableObj);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.partitionObj) {
+ xfer += oprot->writeFieldBegin("partitionObj", ::apache::thrift::protocol::T_STRING, 7);
+ xfer += oprot->writeString(this->partitionObj);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(WriteEventInfo &a, WriteEventInfo &b) {
+ using ::std::swap;
+ swap(a.writeId, b.writeId);
+ swap(a.database, b.database);
+ swap(a.table, b.table);
+ swap(a.files, b.files);
+ swap(a.partition, b.partition);
+ swap(a.tableObj, b.tableObj);
+ swap(a.partitionObj, b.partitionObj);
+ swap(a.__isset, b.__isset);
+}
+
+WriteEventInfo::WriteEventInfo(const WriteEventInfo& other681) {
+ writeId = other681.writeId;
+ database = other681.database;
+ table = other681.table;
+ files = other681.files;
+ partition = other681.partition;
+ tableObj = other681.tableObj;
+ partitionObj = other681.partitionObj;
+ __isset = other681.__isset;
+}
+WriteEventInfo& WriteEventInfo::operator=(const WriteEventInfo& other682) {
+ writeId = other682.writeId;
+ database = other682.database;
+ table = other682.table;
+ files = other682.files;
+ partition = other682.partition;
+ tableObj = other682.tableObj;
+ partitionObj = other682.partitionObj;
+ __isset = other682.__isset;
+ return *this;
+}
+void WriteEventInfo::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "WriteEventInfo(";
+ out << "writeId=" << to_string(writeId);
+ out << ", " << "database=" << to_string(database);
+ out << ", " << "table=" << to_string(table);
+ out << ", " << "files=" << to_string(files);
+ out << ", " << "partition="; (__isset.partition ? (out << to_string(partition)) : (out << "<null>"));
+ out << ", " << "tableObj="; (__isset.tableObj ? (out << to_string(tableObj)) : (out << "<null>"));
+ out << ", " << "partitionObj="; (__isset.partitionObj ? (out << to_string(partitionObj)) : (out << "<null>"));
out << ")";
}
@@ -16789,14 +17055,14 @@ uint32_t ReplTblWriteIdStateRequest::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- uint32_t _size675;
- ::apache::thrift::protocol::TType _etype678;
- xfer += iprot->readListBegin(_etype678, _size675);
- this->partNames.resize(_size675);
- uint32_t _i679;
- for (_i679 = 0; _i679 < _size675; ++_i679)
+ uint32_t _size683;
+ ::apache::thrift::protocol::TType _etype686;
+ xfer += iprot->readListBegin(_etype686, _size683);
+ this->partNames.resize(_size683);
+ uint32_t _i687;
+ for (_i687 = 0; _i687 < _size683; ++_i687)
{
- xfer += iprot->readString(this->partNames[_i679]);
+ xfer += iprot->readString(this->partNames[_i687]);
}
xfer += iprot->readListEnd();
}
@@ -16856,10 +17122,10 @@ uint32_t ReplTblWriteIdStateRequest::write(::apache::thrift::protocol::TProtocol
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 _iter680;
- for (_iter680 = this->partNames.begin(); _iter680 != this->partNames.end(); ++_iter680)
+ std::vector<std::string> ::const_iterator _iter688;
+ for (_iter688 = this->partNames.begin(); _iter688 != this->partNames.end(); ++_iter688)
{
- xfer += oprot->writeString((*_iter680));
+ xfer += oprot->writeString((*_iter688));
}
xfer += oprot->writeListEnd();
}
@@ -16881,23 +17147,23 @@ void swap(ReplTblWriteIdStateRequest &a, ReplTblWriteIdStateRequest &b) {
swap(a.__isset, b.__isset);
}
-ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other681) {
- validWriteIdlist = other681.validWriteIdlist;
- user = other681.user;
- hostName = other681.hostName;
- dbName = other681.dbName;
- tableName = other681.tableName;
- partNames = other681.partNames;
- __isset = other681.__isset;
-}
-ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other682) {
- validWriteIdlist = other682.validWriteIdlist;
- user = other682.user;
- hostName = other682.hostName;
- dbName = other682.dbName;
- tableName = other682.tableName;
- partNames = other682.partNames;
- __isset = other682.__isset;
+ReplTblWriteIdStateRequest::ReplTblWriteIdStateRequest(const ReplTblWriteIdStateRequest& other689) {
+ validWriteIdlist = other689.validWriteIdlist;
+ user = other689.user;
+ hostName = other689.hostName;
+ dbName = other689.dbName;
+ tableName = other689.tableName;
+ partNames = other689.partNames;
+ __isset = other689.__isset;
+}
+ReplTblWriteIdStateRequest& ReplTblWriteIdStateRequest::operator=(const ReplTblWriteIdStateRequest& other690) {
+ validWriteIdlist = other690.validWriteIdlist;
+ user = other690.user;
+ hostName = other690.hostName;
+ dbName = other690.dbName;
+ tableName = other690.tableName;
+ partNames = other690.partNames;
+ __isset = other690.__isset;
return *this;
}
void ReplTblWriteIdStateRequest::printTo(std::ostream& out) const {
@@ -16952,14 +17218,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fullTableNames.clear();
- uint32_t _size683;
- ::apache::thrift::protocol::TType _etype686;
- xfer += iprot->readListBegin(_etype686, _size683);
- this->fullTableNames.resize(_size683);
- uint32_t _i687;
- for (_i687 = 0; _i687 < _size683; ++_i687)
+ uint32_t _size691;
+ ::apache::thrift::protocol::TType _etype694;
+ xfer += iprot->readListBegin(_etype694, _size691);
+ this->fullTableNames.resize(_size691);
+ uint32_t _i695;
+ for (_i695 = 0; _i695 < _size691; ++_i695)
{
- xfer += iprot->readString(this->fullTableNames[_i687]);
+ xfer += iprot->readString(this->fullTableNames[_i695]);
}
xfer += iprot->readListEnd();
}
@@ -17000,10 +17266,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 _iter688;
- for (_iter688 = this->fullTableNames.begin(); _iter688 != this->fullTableNames.end(); ++_iter688)
+ std::vector<std::string> ::const_iterator _iter696;
+ for (_iter696 = this->fullTableNames.begin(); _iter696 != this->fullTableNames.end(); ++_iter696)
{
- xfer += oprot->writeString((*_iter688));
+ xfer += oprot->writeString((*_iter696));
}
xfer += oprot->writeListEnd();
}
@@ -17024,13 +17290,13 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) {
swap(a.validTxnList, b.validTxnList);
}
-GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other689) {
- fullTableNames = other689.fullTableNames;
- validTxnList = other689.validTxnList;
+GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other697) {
+ fullTableNames = other697.fullTableNames;
+ validTxnList = other697.validTxnList;
}
-GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other690) {
- fullTableNames = other690.fullTableNames;
- validTxnList = other690.validTxnList;
+GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other698) {
+ fullTableNames = other698.fullTableNames;
+ validTxnList = other698.validTxnList;
return *this;
}
void GetValidWriteIdsRequest::printTo(std::ostream& out) const {
@@ -17112,14 +17378,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->invalidWriteIds.clear();
- uint32_t _size691;
- ::apache::thrift::protocol::TType _etype694;
- xfer += iprot->readListBegin(_etype694, _size691);
- this->invalidWriteIds.resize(_size691);
- uint32_t _i695;
- for (_i695 = 0; _i695 < _size691; ++_i695)
+ uint32_t _size699;
+ ::apache::thrift::protocol::TType _etype702;
+ xfer += iprot->readListBegin(_etype702, _size699);
+ this->invalidWriteIds.resize(_size699);
+ uint32_t _i703;
+ for (_i703 = 0; _i703 < _size699; ++_i703)
{
- xfer += iprot->readI64(this->invalidWriteIds[_i695]);
+ xfer += iprot->readI64(this->invalidWriteIds[_i703]);
}
xfer += iprot->readListEnd();
}
@@ -17180,10 +17446,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 _iter696;
- for (_iter696 = this->invalidWriteIds.begin(); _iter696 != this->invalidWriteIds.end(); ++_iter696)
+ std::vector<int64_t> ::const_iterator _iter704;
+ for (_iter704 = this->invalidWriteIds.begin(); _iter704 != this->invalidWriteIds.end(); ++_iter704)
{
- xfer += oprot->writeI64((*_iter696));
+ xfer += oprot->writeI64((*_iter704));
}
xfer += oprot->writeListEnd();
}
@@ -17213,21 +17479,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) {
swap(a.__isset, b.__isset);
}
-TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other697) {
- fullTableName = other697.fullTableName;
- writeIdHighWaterMark = other697.writeIdHighWaterMark;
- invalidWriteIds = other697.invalidWriteIds;
- minOpenWriteId = other697.minOpenWriteId;
- abortedBits = other697.abortedBits;
- __isset = other697.__isset;
-}
-TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other698) {
- fullTableName = other698.fullTableName;
- writeIdHighWaterMark = other698.writeIdHighWaterMark;
- invalidWriteIds = other698.invalidWriteIds;
- minOpenWriteId = other698.minOpenWriteId;
- abortedBits = other698.abortedBits;
- __isset = other698.__isset;
+TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other705) {
+ fullTableName = other705.fullTableName;
+ writeIdHighWaterMark = other705.writeIdHighWaterMark;
+ invalidWriteIds = other705.invalidWriteIds;
+ minOpenWriteId = other705.minOpenWriteId;
+ abortedBits = other705.abortedBits;
+ __isset = other705.__isset;
+}
+TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other706) {
+ fullTableName = other706.fullTableName;
+ writeIdHighWaterMark = other706.writeIdHighWaterMark;
+ invalidWriteIds = other706.invalidWriteIds;
+ minOpenWriteId = other706.minOpenWriteId;
+ abortedBits = other706.abortedBits;
+ __isset = other706.__isset;
return *this;
}
void TableValidWriteIds::printTo(std::ostream& out) const {
@@ -17276,14 +17542,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tblValidWriteIds.clear();
- uint32_t _size699;
- ::apache::thrift::protocol::TType _etype702;
- xfer += iprot->readListBegin(_etype702, _size699);
- this->tblValidWriteIds.resize(_size699);
- uint32_t _i703;
- for (_i703 = 0; _i703 < _size699; ++_i703)
+ uint32_t _size707;
+ ::apache::thrift::protocol::TType _etype710;
+ xfer += iprot->readListBegin(_etype710, _size707);
+ this->tblValidWriteIds.resize(_size707);
+ uint32_t _i711;
+ for (_i711 = 0; _i711 < _size707; ++_i711)
{
- xfer += this->tblValidWriteIds[_i703].read(iprot);
+ xfer += this->tblValidWriteIds[_i711].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17314,10 +17580,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 _iter704;
- for (_iter704 = this->tblValidWriteIds.begin(); _iter704 != this->tblValidWriteIds.end(); ++_iter704)
+ std::vector<TableValidWriteIds> ::const_iterator _iter712;
+ for (_iter712 = this->tblValidWriteIds.begin(); _iter712 != this->tblValidWriteIds.end(); ++_iter712)
{
- xfer += (*_iter704).write(oprot);
+ xfer += (*_iter712).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17333,11 +17599,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) {
swap(a.tblValidWriteIds, b.tblValidWriteIds);
}
-GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other705) {
- tblValidWriteIds = other705.tblValidWriteIds;
+GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other713) {
+ tblValidWriteIds = other713.tblValidWriteIds;
}
-GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other706) {
- tblValidWriteIds = other706.tblValidWriteIds;
+GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other714) {
+ tblValidWriteIds = other714.tblValidWriteIds;
return *this;
}
void GetValidWriteIdsResponse::printTo(std::ostream& out) const {
@@ -17418,14 +17684,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txnIds.clear();
- uint32_t _size707;
- ::apache::thrift::protocol::TType _etype710;
- xfer += iprot->readListBegin(_etype710, _size707);
- this->txnIds.resize(_size707);
- uint32_t _i711;
- for (_i711 = 0; _i711 < _size707; ++_i711)
+ uint32_t _size715;
+ ::apache::thrift::protocol::TType _etype718;
+ xfer += iprot->readListBegin(_etype718, _size715);
+ this->txnIds.resize(_size715);
+ uint32_t _i719;
+ for (_i719 = 0; _i719 < _size715; ++_i719)
{
- xfer += iprot->readI64(this->txnIds[_i711]);
+ xfer += iprot->readI64(this->txnIds[_i719]);
}
xfer += iprot->readListEnd();
}
@@ -17446,14 +17712,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->srcTxnToWriteIdList.clear();
- uint32_t _size712;
- ::apache::thrift::protocol::TType _etype715;
- xfer += iprot->readListBegin(_etype715, _size712);
- this->srcTxnToWriteIdList.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->srcTxnToWriteIdList.resize(_size720);
+ uint32_t _i724;
+ for (_i724 = 0; _i724 < _size720; ++_i724)
{
- xfer += this->srcTxnToWriteIdList[_i716].read(iprot);
+ xfer += this->srcTxnToWriteIdList[_i724].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17495,10 +17761,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 _iter717;
- for (_iter717 = this->txnIds.begin(); _iter717 != this->txnIds.end(); ++_iter717)
+ std::vector<int64_t> ::const_iterator _iter725;
+ for (_iter725 = this->txnIds.begin(); _iter725 != this->txnIds.end(); ++_iter725)
{
- xfer += oprot->writeI64((*_iter717));
+ xfer += oprot->writeI64((*_iter725));
}
xfer += oprot->writeListEnd();
}
@@ -17513,10 +17779,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 _iter718;
- for (_iter718 = this->srcTxnToWriteIdList.begin(); _iter718 != this->srcTxnToWriteIdList.end(); ++_iter718)
+ std::vector<TxnToWriteId> ::const_iterator _iter726;
+ for (_iter726 = this->srcTxnToWriteIdList.begin(); _iter726 != this->srcTxnToWriteIdList.end(); ++_iter726)
{
- xfer += (*_iter718).write(oprot);
+ xfer += (*_iter726).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17537,21 +17803,21 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) {
swap(a.__isset, b.__isset);
}
-AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other719) {
- dbName = other719.dbName;
- tableName = other719.tableName;
- txnIds = other719.txnIds;
- replPolicy = other719.replPolicy;
- srcTxnToWriteIdList = other719.srcTxnToWriteIdList;
- __isset = other719.__isset;
-}
-AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other720) {
- dbName = other720.dbName;
- tableName = other720.tableName;
- txnIds = other720.txnIds;
- replPolicy = other720.replPolicy;
- srcTxnToWriteIdList = other720.srcTxnToWriteIdList;
- __isset = other720.__isset;
+AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other727) {
+ dbName = other727.dbName;
+ tableName = other727.tableName;
+ txnIds = other727.txnIds;
+ replPolicy = other727.replPolicy;
+ srcTxnToWriteIdList = other727.srcTxnToWriteIdList;
+ __isset = other727.__isset;
+}
+AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other728) {
+ dbName = other728.dbName;
+ tableName = other728.tableName;
+ txnIds = other728.txnIds;
+ replPolicy = other728.replPolicy;
+ srcTxnToWriteIdList = other728.srcTxnToWriteIdList;
+ __isset = other728.__isset;
return *this;
}
void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const {
@@ -17657,13 +17923,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) {
swap(a.writeId, b.writeId);
}
-TxnToWriteId::TxnToWriteId(const TxnToWriteId& other721) {
- txnId = other721.txnId;
- writeId = other721.writeId;
+TxnToWriteId::TxnToWriteId(const TxnToWriteId& other729) {
+ txnId = other729.txnId;
+ writeId = other729.writeId;
}
-TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other722) {
- txnId = other722.txnId;
- writeId = other722.writeId;
+TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other730) {
+ txnId = other730.txnId;
+ writeId = other730.writeId;
return *this;
}
void TxnToWriteId::printTo(std::ostream& out) const {
@@ -17709,14 +17975,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txnToWriteIds.clear();
- uint32_t _size723;
- ::apache::thrift::protocol::TType _etype726;
- xfer += iprot->readListBegin(_etype726, _size723);
- this->txnToWriteIds.resize(_size723);
- uint32_t _i727;
- for (_i727 = 0; _i727 < _size723; ++_i727)
+ uint32_t _size731;
+ ::apache::thrift::protocol::TType _etype734;
+ xfer += iprot->readListBegin(_etype734, _size731);
+ this->txnToWriteIds.resize(_size731);
+ uint32_t _i735;
+ for (_i735 = 0; _i735 < _size731; ++_i735)
{
- xfer += this->txnToWriteIds[_i727].read(iprot);
+ xfer += this->txnToWriteIds[_i735].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -17747,10 +18013,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 _iter728;
- for (_iter728 = this->txnToWriteIds.begin(); _iter728 != this->txnToWriteIds.end(); ++_iter728)
+ std::vector<TxnToWriteId> ::const_iterator _iter736;
+ for (_iter736 = this->txnToWriteIds.begin(); _iter736 != this->txnToWriteIds.end(); ++_iter736)
{
- xfer += (*_iter728).write(oprot);
+ xfer += (*_iter736).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -17766,11 +18032,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) {
swap(a.txnToWriteIds, b.txnToWriteIds);
}
-AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other729) {
- txnToWriteIds = other729.txnToWriteIds;
+AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other737) {
+ txnToWriteIds = other737.txnToWriteIds;
}
-AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other730) {
- txnToWriteIds = other730.txnToWriteIds;
+AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other738) {
+ txnToWriteIds = other738.txnToWriteIds;
return *this;
}
void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const {
@@ -17848,9 +18114,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast731;
- xfer += iprot->readI32(ecast731);
- this->type = (LockType::type)ecast731;
+ int32_t ecast739;
+ xfer += iprot->readI32(ecast739);
+ this->type = (LockType::type)ecast739;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -17858,9 +18124,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast732;
- xfer += iprot->readI32(ecast732);
- this->level = (LockLevel::type)ecast732;
+ int32_t ecast740;
+ xfer += iprot->readI32(ecast740);
+ this->level = (LockLevel::type)ecast740;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -17892,9 +18158,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast733;
- xfer += iprot->readI32(ecast733);
- this->operationType = (DataOperationType::type)ecast733;
+ int32_t ecast741;
+ xfer += iprot->readI32(ecast741);
+ this->operationType = (DataOperationType::type)ecast741;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -17994,27 +18260,27 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other734) {
- type = other734.type;
- level = other734.level;
- dbname = other734.dbname;
- tablename = other734.tablename;
- partitionname = other734.partitionname;
- operationType = other734.operationType;
- isTransactional = other734.isTransactional;
- isDynamicPartitionWrite = other734.isDynamicPartitionWrite;
- __isset = other734.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other735) {
- type = other735.type;
- level = other735.level;
- dbname = other735.dbname;
- tablename = other735.tablename;
- partitionname = other735.partitionname;
- operationType = other735.operationType;
- isTransactional = other735.isTransactional;
- isDynamicPartitionWrite = other735.isDynamicPartitionWrite;
- __isset = other735.__isset;
+LockComponent::LockComponent(const LockComponent& other742) {
+ type = other742.type;
+ level = other742.level;
+ dbname = other742.dbname;
+ tablename = other742.tablename;
+ partitionname = other742.partitionname;
+ operationType = other742.operationType;
+ isTransactional = other742.isTransactional;
+ isDynamicPartitionWrite = other742.isDynamicPartitionWrite;
+ __isset = other742.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other743) {
+ type = other743.type;
+ level = other743.level;
+ dbname = other743.dbname;
+ tablename = other743.tablename;
+ partitionname = other743.partitionname;
+ operationType = other743.operationType;
+ isTransactional = other743.isTransactional;
+ isDynamicPartitionWrite = other743.isDynamicPartitionWrite;
+ __isset = other743.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -18086,14 +18352,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size736;
- ::apache::thrift::protocol::TType _etype739;
- xfer += iprot->readListBegin(_etype739, _size736);
- this->component.resize(_size736);
- uint32_t _i740;
- for (_i740 = 0; _i740 < _size736; ++_i740)
+ uint32_t _size744;
+ ::apache::thrift::protocol::TType _etype747;
+ xfer += iprot->readListBegin(_etype747, _size744);
+ this->component.resize(_size744);
+ uint32_t _i748;
+ for (_i748 = 0; _i748 < _size744; ++_i748)
{
- xfer += this->component[_i740].read(iprot);
+ xfer += this->component[_i748].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -18160,10 +18426,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 _iter741;
- for (_iter741 = this->component.begin(); _iter741 != this->component.end(); ++_iter741)
+ std::vector<LockComponent> ::const_iterator _iter749;
+ for (_iter749 = this->component.begin(); _iter749 != this->component.end(); ++_iter749)
{
- xfer += (*_iter741).write(oprot);
+ xfer += (*_iter749).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -18202,21 +18468,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other742) {
- component = other742.component;
- txnid = other742.txnid;
- user = other742.user;
- hostname = other742.hostname;
- agentInfo = other742.agentInfo;
- __isset = other742.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other743) {
- component = other743.component;
- txnid = other743.txnid;
- user = other743.user;
- hostname = other743.hostname;
- agentInfo = other743.agentInfo;
- __isset = other743.__isset;
+LockRequest::LockRequest(const LockRequest& other750) {
+ component = other750.component;
+ txnid = other750.txnid;
+ user = other750.user;
+ hostname = other750.hostname;
+ agentInfo = other750.agentInfo;
+ __isset = other750.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other751) {
+ component = other751.component;
+ txnid = other751.txnid;
+ user = other751.user;
+ hostname = other751.hostname;
+ agentInfo = other751.agentInfo;
+ __isset = other751.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -18276,9 +18542,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast744;
- xfer += iprot->readI32(ecast744);
- this->state = (LockState::type)ecast744;
+ int32_t ecast752;
+ xfer += iprot->readI32(ecast752);
+ this->state = (LockState::type)ecast752;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -18324,13 +18590,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other745) {
- lockid = other745.lockid;
- state = other745.state;
+LockResponse::LockResponse(const LockResponse& other753) {
+ lockid = other753.lockid;
+ state = other753.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other746) {
- lockid = other746.lockid;
- state = other746.state;
+LockResponse& LockResponse::operator=(const LockResponse& other754) {
+ lockid = other754.lockid;
+ state = other754.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -18452,17 +18718,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other747) {
- lockid = other747.lockid;
- txnid = other747.txnid;
- elapsed_ms = other747.elapsed_ms;
- __isset = other747.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other755) {
+ lockid = other755.lockid;
+ txnid = other755.txnid;
+ elapsed_ms = other755.elapsed_ms;
+ __isset = other755.__isset;
}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other748) {
- lockid = other748.lockid;
- txnid = other748.txnid;
- elapsed_ms = other748.elapsed_ms;
- __isset = other748.__isset;
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other756) {
+ lockid = other756.lockid;
+ txnid = other756.txnid;
+ elapsed_ms = other756.elapsed_ms;
+ __isset = other756.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -18546,11 +18812,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other749) {
- lockid = other749.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other757) {
+ lockid = other757.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other750) {
- lockid = other750.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other758) {
+ lockid = other758.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -18689,19 +18955,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other751) {
- dbname = other751.dbname;
- tablename = other751.tablename;
- partname = other751.partname;
- isExtended = other751.isExtended;
- __isset = other751.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other759) {
+ dbname = other759.dbname;
+ tablename = other759.tablename;
+ partname = other759.partname;
+ isExtended = other759.isExtended;
+ __isset = other759.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other752) {
- dbname = other752.dbname;
- tablename = other752.tablename;
- partname = other752.partname;
- isExtended = other752.isExtended;
- __isset = other752.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other760) {
+ dbname = other760.dbname;
+ tablename = other760.tablename;
+ partname = other760.partname;
+ isExtended = other760.isExtended;
+ __isset = other760.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -18854,9 +19120,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast753;
- xfer += iprot->readI32(ecast753);
- this->state = (LockState::type)ecast753;
+ int32_t ecast761;
+ xfer += iprot->readI32(ecast761);
+ this->state = (LockState::type)ecast761;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -18864,9 +19130,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast754;
- xfer += iprot->readI32(ecast754);
- this->type = (LockType::type)ecast754;
+ int32_t ecast762;
+ xfer += iprot->readI32(ecast762);
+ this->type = (LockType::type)ecast762;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -19082,43 +19348,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other755) {
- lockid = other755.lockid;
- dbname = other755.dbname;
- tablename = other755.tablename;
- partname = other755.partname;
- state = other755.state;
- type = other755.type;
- txnid = other755.txnid;
- lastheartbeat = other755.lastheartbeat;
- acquiredat = other755.acquiredat;
- user = other755.user;
- hostname = other755.hostname;
- heartbeatCount = other755.heartbeatCount;
- agentInfo = other755.agentInfo;
- blockedByExtId = other755.blockedByExtId;
- blockedByIntId = other755.blockedByIntId;
- lockIdInternal = other755.lockIdInternal;
- __isset = other755.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other763) {
+ lockid = other763.lockid;
+ dbname = other763.dbname;
+ tablename = other763.tablename;
+ partname = other763.partname;
+ state = other763.state;
+ type = other763.type;
+ txnid = other763.txnid;
+ lastheartbeat = other763.lastheartbeat;
+ acquiredat = other763.acquiredat;
+ user = other763.user;
+ hostname = other763.hostname;
+ heartbeatCount = other763.heartbeatCount;
+ agentInfo = other763.agentInfo;
+ blockedByExtId = other763.blockedByExtId;
+ blockedByIntId = other763.blockedByIntId;
+ lockIdInternal = other763.lockIdInternal;
+ __isset = other763.__isset;
}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other756) {
- lockid = other756.lockid;
- dbname = other756.dbname;
- tablename = other756.tablename;
- partname = other756.partname;
- state = other756.state;
- type = other756.type;
- txnid = other756.txnid;
- lastheartbeat = other756.lastheartbeat;
- acquiredat = other756.acquiredat;
- user = other756.user;
- hostname = other756.hostname;
- heartbeatCount = other756.heartbeatCount;
- agentInfo = other756.agentInfo;
- blockedByExtId = other756.blockedByExtId;
- blockedByIntId = other756.blockedByIntId;
- lockIdInternal = other756.lockIdInternal;
- __isset = other756.__isset;
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other764) {
+ lockid = other764.lockid;
+ dbname = other764.dbname;
+ tablename = other764.tablename;
+ partname = other764.partname;
+ state = other764.state;
+ type = other764.type;
+ txnid = other764.txnid;
+ lastheartbeat = other764.lastheartbeat;
+ acquiredat = other764.acquiredat;
+ user = other764.user;
+ hostname = other764.hostname;
+ heartbeatCount = other764.heartbeatCount;
+ agentInfo = other764.agentInfo;
+ blockedByExtId = other764.blockedByExtId;
+ blockedByIntId = other764.blockedByIntId;
+ lockIdInternal = other764.lockIdInternal;
+ __isset = other764.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -19177,14 +19443,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size757;
- ::apache::thrift::protocol::TType _etype760;
- xfer += iprot->readListBegin(_etype760, _size757);
- this->locks.resize(_size757);
- uint32_t _i761;
- for (_i761 = 0; _i761 < _size757; ++_i761)
+ uint32_t _size765;
+ ::apache::thrift::protocol::TType _etype768;
+ xfer += iprot->readListBegin(_etype768, _size765);
+ this->locks.resize(_size765);
+ uint32_t _i769;
+ for (_i769 = 0; _i769 < _size765; ++_i769)
{
- xfer += this->locks[_i761].read(iprot);
+ xfer += this->locks[_i769].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -19213,10 +19479,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 _iter762;
- for (_iter762 = this->locks.begin(); _iter762 != this->locks.end(); ++_iter762)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter770;
+ for (_iter770 = this->locks.begin(); _iter770 != this->locks.end(); ++_iter770)
{
- xfer += (*_iter762).write(oprot);
+ xfer += (*_iter770).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -19233,13 +19499,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other763) {
- locks = other763.locks;
- __isset = other763.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other771) {
+ locks = other771.locks;
+ __isset = other771.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other764) {
- locks = other764.locks;
- __isset = other764.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other772) {
+ locks = other772.locks;
+ __isset = other772.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -19340,15 +19606,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other765) {
- lockid = other765.lockid;
- txnid = other765.txnid;
- __isset = other765.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other773) {
+ lockid = other773.lockid;
+ txnid = other773.txnid;
+ __isset = other773.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other766) {
- lockid = other766.lockid;
- txnid = other766.txnid;
- __isset = other766.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other774) {
+ lockid = other774.lockid;
+ txnid = other774.txnid;
+ __isset = other774.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -19451,13 +19717,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other767) {
- min = other767.min;
- max = other767.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other775) {
+ min = other775.min;
+ max = other775.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other768) {
- min = other768.min;
- max = other768.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other776) {
+ min = other776.min;
+ max = other776.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -19508,15 +19774,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size769;
- ::apache::thrift::protocol::TType _etype772;
- xfer += iprot->readSetBegin(_etype772, _size769);
- uint32_t _i773;
- for (_i773 = 0; _i773 < _size769; ++_i773)
+ uint32_t _size777;
+ ::apache::thrift::protocol::TType _etype780;
+ xfer += iprot->readSetBegin(_etype780, _size777);
+ uint32_t _i781;
+ for (_i781 = 0; _i781 < _size777; ++_i781)
{
- int64_t _elem774;
- xfer += iprot->readI64(_elem774);
- this->aborted.insert(_elem774);
+ int64_t _elem782;
+ xfer += iprot->readI64(_elem782);
+ this->aborted.insert(_elem782);
}
xfer += iprot->readSetEnd();
}
@@ -19529,15 +19795,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size775;
- ::apache::thrift::protocol::TType _etype778;
- xfer += iprot->readSetBegin(_etype778, _size775);
- uint32_t _i779;
- for (_i779 = 0; _i779 < _size775; ++_i779)
+ uint32_t _size783;
+ ::apache::thrift::protocol::TType _etype786;
+ xfer += iprot->readSetBegin(_etype786, _size783);
+ uint32_t _i787;
+ for (_i787 = 0; _i787 < _size783; ++_i787)
{
- int64_t _elem780;
- xfer += iprot->readI64(_elem780);
- this->nosuch.insert(_elem780);
+ int64_t _elem788;
+ xfer += iprot->readI64(_elem788);
+ this->nosuch.insert(_elem788);
}
xfer += iprot->readSetEnd();
}
@@ -19570,10 +19836,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 _iter781;
- for (_iter781 = this->aborted.begin(); _iter781 != this->aborted.end(); ++_iter781)
+ std::set<int64_t> ::const_iterator _iter789;
+ for (_iter789 = this->aborted.begin(); _iter789 != this->aborted.end(); ++_iter789)
{
- xfer += oprot->writeI64((*_iter781));
+ xfer += oprot->writeI64((*_iter789));
}
xfer += oprot->writeSetEnd();
}
@@ -19582,10 +19848,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 _iter782;
- for (_iter782 = this->nosuch.begin(); _iter782 != this->nosuch.end(); ++_iter782)
+ std::set<int64_t> ::const_iterator _iter790;
+ for (_iter790 = this->nosuch.begin(); _iter790 != this->nosuch.end(); ++_iter790)
{
- xfer += oprot->writeI64((*_iter782));
+ xfer += oprot->writeI64((*_iter790));
}
xfer += oprot->writeSetEnd();
}
@@ -19602,13 +19868,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other783) {
- aborted = other783.aborted;
- nosuch = other783.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other791) {
+ aborted = other791.aborted;
+ nosuch = other791.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other784) {
- aborted = other784.aborted;
- nosuch = other784.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other792) {
+ aborted = other792.aborted;
+ nosuch = other792.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -19701,9 +19967,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast785;
- xfer += iprot->readI32(ecast785);
- this->type = (CompactionType::type)ecast785;
+ int32_t ecast793;
+ xfer += iprot->readI32(ecast793);
+ this->type = (CompactionType::type)ecast793;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -19721,17 +19987,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- uint32_t _size786;
- ::apache::thrift::protocol::TType _ktype787;
- ::apache::thrift::protocol::TType _vtype788;
- xfer += iprot->readMapBegin(_ktype787, _vtype788, _size786);
- uint32_t _i790;
- for (_i790 = 0; _i790 < _size786; ++_i790)
+ uint32_t _size794;
+ ::apache::thrift::protocol::TType _ktype795;
+ ::apache::thrift::protocol::TType _vtype796;
+ xfer += iprot->readMapBegin(_ktype795, _vtype796, _size794);
+ uint32_t _i798;
+ for (_i798 = 0; _i798 < _size794; ++_i798)
{
- std::string _key791;
- xfer += iprot->readString(_key791);
- std::string& _val792 = this->properties[_key791];
- xfer += iprot->readString(_val792);
+ std::string _key799;
+ xfer += iprot->readString(_key799);
+ std::string& _val800 = this->properties[_key799];
+ xfer += iprot->readString(_val800);
}
xfer += iprot->readMapEnd();
}
@@ -19789,11 +20055,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 _iter793;
- for (_iter793 = this->properties.begin(); _iter793 != this->properties.end(); ++_iter793)
+ std::map<std::string, std::string> ::const_iterator _iter801;
+ for (_iter801 = this->properties.begin(); _iter801 != this->properties.end(); ++_iter801)
{
- xfer += oprot->writeString(_iter793->first);
- xfer += oprot->writeString(_iter793->second);
+ xfer += oprot->writeString(_iter801->first);
+ xfer += oprot->writeString(_iter801->second);
}
xfer += oprot->writeMapEnd();
}
@@ -19815,23 +20081,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other794) {
- dbname = other794.dbname;
- tablename = other794.tablename;
- partitionname = other794.partitionname;
- type = other794.type;
- runas = other794.runas;
- properties = other794.properties;
- __isset = other794.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other795) {
- dbname = other795.dbname;
- tablename = other795.tablename;
- partitionname = other795.partitionname;
- type = other795.type;
- runas = other795.runas;
- properties = other795.properties;
- __isset = other795.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other802) {
+ dbname = other802.dbname;
+ tablename = other802.tablename;
+ partitionname = other802.partitionname;
+ type = other802.type;
+ runas = other802.runas;
+ properties = other802.properties;
+ __isset = other802.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other803) {
+ dbname = other803.dbname;
+ tablename = other803.tablename;
+ partitionname = other803.partitionname;
+ type = other803.type;
+ runas = other803.runas;
+ properties = other803.properties;
+ __isset = other803.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -19958,15 +20224,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) {
swap(a.accepted, b.accepted);
}
-CompactionResponse::CompactionResponse(const CompactionResponse& other796) {
- id = other796.id;
- state = other796.state;
- accepted = other796.accepted;
+CompactionResponse::CompactionResponse(const CompactionResponse& other804) {
+ id = other804.id;
+ state = other804.state;
+ accepted = other804.accepted;
}
-CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other797) {
- id = other797.id;
- state = other797.state;
- accepted = other797.accepted;
+CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other805) {
+ id = other805.id;
+ state = other805.state;
+ accepted = other805.accepted;
return *this;
}
void CompactionResponse::printTo(std::ostream& out) const {
@@ -20027,11 +20293,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other798) {
- (void) other798;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other806) {
+ (void) other806;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other799) {
- (void) other799;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other807) {
+ (void) other807;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -20157,9 +20423,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast800;
- xfer += iprot->readI32(ecast800);
- this->type = (CompactionType::type)ecast800;
+ int32_t ecast808;
+ xfer += iprot->readI32(ecast808);
+ this->type = (CompactionType::type)ecast808;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -20346,37 +20612,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other801) {
- dbname = other801.dbname;
- tablename = other801.tablename;
- partitionname = other801.partitionname;
- type = other801.type;
- state = other801.state;
- workerid = other801.workerid;
- start = other801.start;
- runAs = other801.runAs;
- hightestTxnId = other801.hightestTxnId;
- metaInfo = other801.metaInfo;
- endTime = other801.endTime;
- hadoopJobId = other801.hadoopJobId;
- id = other801.id;
- __isset = other801.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other802) {
- dbname = other802.dbname;
- tablename = other802.tablename;
- partitionname = other802.partitionname;
- type = other802.type;
- state = other802.state;
- workerid = other802.workerid;
- start = other802.start;
- runAs = other802.runAs;
- hightestTxnId = other802.hightestTxnId;
- metaInfo = other802.metaInfo;
- endTime = other802.endTime;
- hadoopJobId = other802.hadoopJobId;
- id = other802.id;
- __isset = other802.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other809) {
+ dbname = other809.dbname;
+ tablename = other809.tablename;
+ partitionname = other809.partitionname;
+ type = other809.type;
+ state = other809.state;
+ workerid = other809.workerid;
+ start = other809.start;
+ runAs = other809.runAs;
+ hightestTxnId = other809.hightestTxnId;
+ metaInfo = other809.metaInfo;
+ endTime = other809.endTime;
+ hadoopJobId = other809.hadoopJobId;
+ id = other809.id;
+ __isset = other809.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other810) {
+ dbname = other810.dbname;
+ tablename = other810.tablename;
+ partitionname = other810.partitionname;
+ type = other810.type;
+ state = other810.state;
+ workerid = other810.workerid;
+ start = other810.start;
+ runAs = other810.runAs;
+ hightestTxnId = other810.hightestTxnId;
+ metaInfo = other810.metaInfo;
+ endTime = other810.endTime;
+ hadoopJobId = other810.hadoopJobId;
+ id = other810.id;
+ __isset = other810.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -20433,14 +20699,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size803;
- ::apache::thrift::protocol::TType _etype806;
- xfer += iprot->readListBegin(_etype806, _size803);
- this->compacts.resize(_size803);
- uint32_t _i807;
- for (_i807 = 0; _i807 < _size803; ++_i807)
+ uint32_t _size811;
+ ::apache::thrift::protocol::TType _etype814;
+ xfer += iprot->readListBegin(_etype814, _size811);
+ this->compacts.resize(_size811);
+ uint32_t _i815;
+ for (_i815 = 0; _i815 < _size811; ++_i815)
{
- xfer += this->compacts[_i807].read(iprot);
+ xfer += this->compacts[_i815].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -20471,10 +20737,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 _iter808;
- for (_iter808 = this->compacts.begin(); _iter808 != this->compacts.end(); ++_iter808)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter816;
+ for (_iter816 = this->compacts.begin(); _iter816 != this->compacts.end(); ++_iter816)
{
- xfer += (*_iter808).write(oprot);
+ xfer += (*_iter816).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -20490,11 +20756,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other809) {
- compacts = other809.compacts;
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other817) {
+ compacts = other817.compacts;
}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other810) {
- compacts = other810.compacts;
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other818) {
+ compacts = other818.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -20596,14 +20862,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- uint32_t _size811;
- ::apache::thrift::protocol::TType _etype814;
- xfer += iprot->readListBegin(_etype814, _size811);
- this->partitionnames.resize(_size811);
- uint32_t _i815;
- for (_i815 = 0; _i815 < _size811; ++_i815)
+ uint32_t _size819;
+ ::apache::thrift::protocol::TType _etype822;
+ xfer += iprot->readListBegin(_etype822, _size819);
+ this->partitionnames.resize(_size819);
+ uint32_t _i823;
+ for (_i823 = 0; _i823 < _size819; ++_i823)
{
- xfer += iprot->readString(this->partitionnames[_i815]);
+ xfer += iprot->readString(this->partitionnames[_i823]);
}
xfer += iprot->readListEnd();
}
@@ -20614,9 +20880,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast816;
- xfer += iprot->readI32(ecast816);
- this->operationType = (DataOperationType::type)ecast816;
+ int32_t ecast824;
+ xfer += iprot->readI32(ecast824);
+ this->operationType = (DataOperationType::type)ecast824;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -20668,10 +20934,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 _iter817;
- for (_iter817 = this->partitionnames.begin(); _iter817 != this->partitionnames.end(); ++_iter817)
+ std::vector<std::string> ::const_iterator _iter825;
+ for (_iter825 = this->partitionnames.begin(); _iter825 != this->partitionnames.end(); ++_iter825)
{
- xfer += oprot->writeString((*_iter817));
+ xfer += oprot->writeString((*_iter825));
}
xfer += oprot->writeListEnd();
}
@@ -20698,23 +20964,23 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.__isset, b.__isset);
}
-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other818) {
- txnid = other818.txnid;
- writeid = other818.writeid;
- dbname = other818.dbname;
- tablename = other818.tablename;
- partitionnames = other818.partitionnames;
- operationType = other818.operationType;
- __isset = other818.__isset;
-}
-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other819) {
- txnid = other819.txnid;
- writeid = other819.writeid;
- dbname = other819.dbname;
- tablename = other819.tablename;
- partitionnames = other819.partitionnames;
- operationType = other819.operationType;
- __isset = other819.__isset;
+AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other826) {
+ txnid = other826.txnid;
+ writeid = other826.writeid;
+ dbname = other826.dbname;
+ tablename = other826.tablename;
+ partitionnames = other826.partitionnames;
+ operationType = other826.operationType;
+ __isset = other826.__isset;
+}
+AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other827) {
+ txnid = other827.txnid;
+ writeid = other827.writeid;
+ dbname = other827.dbname;
+ tablename = other827.tablename;
+ partitionnames = other827.partitionnames;
+ operationType = other827.operationType;
+ __isset = other827.__isset;
return *this;
}
void AddDynamicPartitions::printTo(std::ostream& out) const {
@@ -20897,23 +21163,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) {
swap(a.__isset, b.__isset);
}
-BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other820) {
- isnull = other820.isnull;
- time = other820.time;
- txnid = other820.txnid;
- dbname = other820.dbname;
- tablename = other820.tablename;
- partitionname = other820.partitionname;
- __isset = other820.__isset;
-}
-BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other821) {
- isnull = other821.isnull;
- time = other821.time;
- txnid = other821.txnid;
- dbname = other821.dbname;
- tablename = other821.tablename;
- partitionname = other821.partitionname;
- __isset = other821.__isset;
+BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other828) {
+ isnull = other828.isnull;
+ time = other828.time;
+ txnid = other828.txnid;
+ dbname = other828.dbname;
+ tablename = other828.tablename;
+ partitionname = other828.partitionname;
+ __isset = other828.__isset;
+}
+BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other829) {
+ isnull = other829.isnull;
+ time = other829.time;
+ txnid = other829.txnid;
+ dbname = other829.dbname;
+ tablename = other829.tablename;
+ partitionname = other829.partitionname;
+ __isset = other829.__isset;
return *this;
}
void BasicTxnInfo::printTo(std::ostream& out) const {
@@ -21007,15 +21273,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->tablesUsed.clear();
- uint32_t _size822;
- ::apache::thrift::protocol::TType _etype825;
- xfer += iprot->readSetBegin(_etype825, _size822);
- uint32_t _i826;
- for (_i826 = 0; _i826 < _size822; ++_i826)
+ uint32_t _size830;
+ ::apache::thrift::protocol::TType _etype833;
+ xfer += iprot->readSetBegin(_etype833, _size830);
+ uint32_t _i834;
+ for (_i834 = 0; _i834 < _size830; ++_i834)
{
- std::string _elem827;
- xfer += iprot->readString(_elem827);
- this->tablesUsed.insert(_elem827);
+ std::string _elem835;
+ xfer += iprot->readString(_elem835);
+ this->tablesUsed.insert(_elem835);
}
xfer += iprot->readSetEnd();
}
@@ -21072,10 +21338,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 _iter828;
- for (_iter828 = this->tablesUsed.begin(); _iter828 != this->tablesUsed.end(); ++_iter828)
+ std::set<std::string> ::const_iterator _iter836;
+ for (_iter836 = this->tablesUsed.begin(); _iter836 != this->tablesUsed.end(); ++_iter836)
{
- xfer += oprot->writeString((*_iter828));
+ xfer += oprot->writeString((*_iter836));
}
xfer += oprot->writeSetEnd();
}
@@ -21101,21 +21367,21 @@ void swap(CreationMetadata &a, CreationMetadata &b) {
swap(a.__isset, b.__isset);
}
-CreationMetadata::CreationMetadata(const CreationMetadata& other829) {
- catName = other829.catName;
- dbName = other829.dbName;
- tblName = other829.tblName;
- tablesUsed = other829.tablesUsed;
- validTxnList = other829.validTxnList;
- __isset = other829.__isset;
-}
-CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other830) {
- catName = other830.catName;
- dbName = other830.dbName;
- tblName = other830.tblName;
- tablesUsed = other830.tablesUsed;
- validTxnList = other830.validTxnList;
- __isset = other830.__isset;
+CreationMetadata::CreationMetadata(const CreationMetadata& other837) {
+ catName = other837.catName;
+ dbName = other837.dbName;
+ tblName = other837.tblName;
+ tablesUsed = other837.tablesUsed;
+ validTxnList = other837.validTxnList;
+ __isset = other837.__isset;
+}
+CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other838) {
+ catName = other838.catName;
+ dbName = other838.dbName;
+ tblName = other838.tblName;
+ tablesUsed = other838.tablesUsed;
+ validTxnList = other838.validTxnList;
+ __isset = other838.__isset;
return *this;
}
void CreationMetadata::printTo(std::ostream& out) const {
@@ -21221,15 +21487,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other831) {
- lastEvent = other831.lastEvent;
- maxEvents = other831.maxEvents;
- __isset = other831.__isset;
+NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other839) {
+ lastEvent = other839.lastEvent;
+ maxEvents = other839.maxEvents;
+ __isset = other839.__isset;
}
-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other832) {
- lastEvent = other832.lastEvent;
- maxEvents = other832.maxEvents;
- __isset = other832.__isset;
+NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other840) {
+ lastEvent = other840.lastEvent;
+ maxEvents = other840.maxEvents;
+ __isset = other840.__isset;
return *this;
}
void NotificationEventRequest::printTo(std::ostream& out) const {
@@ -21449,27 +21715,27 @@ void swap(NotificationEvent &a, NotificationEvent &b) {
swap(a.__isset, b.__isset);
}
-NotificationEvent::NotificationEvent(const NotificationEvent& other833) {
- eventId = other833.eventId;
- eventTime = other833.eventTime;
- eventType = other833.eventType;
- dbName = other833.dbName;
- tableName = other833.tableName;
- message = other833.message;
- messageFormat = other833.messageFormat;
- catName = other833.catName;
- __isset = other833.__isset;
-}
-NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other834) {
- eventId = other834.eventId;
- eventTime = other834.eventTime;
- eventType = other834.eventType;
- dbName = other834.dbName;
- tableName = other834.tableName;
- message = other834.message;
- messageFormat = other834.messageFormat;
- catName = other834.catName;
- __isset = other834.__isset;
+NotificationEvent::NotificationEvent(const NotificationEvent& other841) {
+ eventId = other841.eventId;
+ eventTime = other841.eventTime;
+ eventType = other841.eventType;
+ dbName = other841.dbName;
+ tableName = other841.tableName;
+ message = other841.message;
+ messageFormat = other841.messageFormat;
+ catName = other841.catName;
+ __isset = other841.__isset;
+}
+NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other842) {
+ eventId = other842.eventId;
+ eventTime = other842.eventTime;
+ eventType = other842.eventType;
+ dbName = other842.dbName;
+ tableName = other842.tableName;
+ message = other842.message;
+ messageFormat = other842.messageFormat;
+ catName = other842.catName;
+ __isset = other842.__isset;
return *this;
}
void NotificationEvent::printTo(std::ostream& out) const {
@@ -21521,14 +21787,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->events.clear();
- uint32_t _size835;
- ::apache::thrift::protocol::TType _etype838;
- xfer += iprot->readListBegin(_etype838, _size835);
- this->events.resize(_size835);
- uint32_t _i839;
- for (_i839 = 0; _i839 < _size835; ++_i839)
+ uint32_t _size843;
+ ::apache::thrift::protocol::TType _etype846;
+ xfer += iprot->readListBegin(_etype846, _size843);
+ this->events.resize(_size843);
+ uint32_t _i847;
+ for (_i847 = 0; _i847 < _size843; ++_i847)
{
- xfer += this->events[_i839].read(iprot);
+ xfer += this->events[_i847].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -21559,10 +21825,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 _iter840;
- for (_iter840 = this->events.begin(); _iter840 != this->events.end(); ++_iter840)
+ std::vector<NotificationEvent> ::const_iterator _iter848;
+ for (_iter848 = this->events.begin(); _iter848 != this->events.end(); ++_iter848)
{
- xfer += (*_iter840).write(oprot);
+ xfer += (*_iter848).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -21578,11 +21844,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
swap(a.events, b.events);
}
-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other841) {
- events = other841.events;
+NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other849) {
+ events = other849.events;
}
-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other842) {
- events = other842.events;
+NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other850) {
+ events = other850.events;
return *this;
}
void NotificationEventResponse::printTo(std::ostream& out) const {
@@ -21664,11 +21930,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
swap(a.eventId, b.eventId);
}
-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other843) {
- eventId = other843.eventId;
+CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other851) {
+ eventId = other851.eventId;
}
-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other844) {
- eventId = other844.eventId;
+CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other852) {
+ eventId = other852.eventId;
return *this;
}
void CurrentNotificationEventId::printTo(std::ostream& out) const {
@@ -21790,17 +22056,17 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b)
swap(a.__isset, b.__isset);
}
-NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other845) {
- fromEventId = other845.fromEventId;
- dbName = other845.dbName;
- catName = other845.catName;
- __isset = other845.__isset;
+NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other853) {
+ fromEventId = other853.fromEventId;
+ dbName = other853.dbName;
+ catName = other853.catName;
+ __isset = other853.__isset;
}
-NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other846) {
- fromEventId = other846.fromEventId;
- dbName = other846.dbName;
- catName = other846.catName;
- __isset = other846.__isset;
+NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other854) {
+ fromEventId = other854.fromEventId;
+ dbName = other854.dbName;
+ catName = other854.catName;
+ __isset = other854.__isset;
return *this;
}
void NotificationEventsCountRequest::printTo(std::ostream& out) const {
@@ -21884,11 +22150,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b
swap(a.eventsCount, b.eventsCount);
}
-NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other847) {
- eventsCount = other847.eventsCount;
+NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other855) {
+ eventsCount = other855.eventsCount;
}
-NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other848) {
- eventsCount = other848.eventsCount;
+NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other856) {
+ eventsCount = other856.eventsCount;
return *this;
}
void NotificationEventsCountResponse::printTo(std::ostream& out) const {
@@ -21917,6 +22183,11 @@ void InsertEventRequestData::__set_filesAddedChecksum(const std::vector<std::str
__isset.filesAddedChecksum = true;
}
+void InsertEventRequestData::__set_subDirectoryList(const std::vector<std::string> & val) {
+ this->subDirectoryList = val;
+__isset.subDirectoryList = true;
+}
+
uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* iprot) {
apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
@@ -21951,14 +22222,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAdded.clear();
- uint32_t _size849;
- ::apache::thrift::protocol::TType _etype852;
- xfer += iprot->readListBegin(_etype852, _size849);
- this->filesAdded.resize(_size849);
- uint32_t _i853;
- for (_i853 = 0; _i853 < _size849; ++_i853)
+ uint32_t _size857;
+ ::apache::thrift::protocol::TType _etype860;
+ xfer += iprot->readListBegin(_etype860, _size857);
+ this->filesAdded.resize(_size857);
+ uint32_t _i861;
+ for (_i861 = 0; _i861 < _size857; ++_i861)
{
- xfer += iprot->readString(this->filesAdded[_i853]);
+ xfer += iprot->readString(this->filesAdded[_i861]);
}
xfer += iprot->readListEnd();
}
@@ -21971,14 +22242,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAddedChecksum.clear();
- uint32_t _size854;
- ::apache::thrift::protocol::TType _etype857;
- xfer += iprot->readListBegin(_etype857, _size854);
- this->filesAddedChecksum.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->filesAddedChecksum.resize(_size862);
+ uint32_t _i866;
+ for (_i866 = 0; _i866 < _size862; ++_i866)
{
- xfer += iprot->readString(this->filesAddedChecksum[_i858]);
+ xfer += iprot->readString(this->filesAddedChecksum[_i866]);
}
xfer += iprot->readListEnd();
}
@@ -21987,6 +22258,26 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
xfer += iprot->skip(ftype);
}
break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->subDirectoryList.clear();
+ uint32_t _size867;
+ ::apache::thrift::protocol::TType _etype870;
+ xfer += iprot->readListBegin(_etype870, _size867);
+ this->subDirectoryList.resize(_size867);
+ uint32_t _i871;
+ for (_i871 = 0; _i871 < _size867; ++_i871)
+ {
+ xfer += iprot->readString(this->subDirectoryList[_i871]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.subDirectoryList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -22014,10 +22305,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 _iter859;
- for (_iter859 = this->filesAdded.begin(); _iter859 != this->filesAdded.end(); ++_iter859)
+ std::vector<std::string> ::const_iterator _iter872;
+ for (_iter872 = this->filesAdded.begin(); _iter872 != this->filesAdded.end(); ++_iter872)
{
- xfer += oprot->writeString((*_iter859));
+ xfer += oprot->writeString((*_iter872));
}
xfer += oprot->writeListEnd();
}
@@ -22027,10 +22318,23 @@ 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 _iter860;
- for (_iter860 = this->filesAddedChecksum.begin(); _iter860 != this->filesAddedChecksum.end(); ++_iter860)
+ std::vector<std::string> ::const_iterator _iter873;
+ for (_iter873 = this->filesAddedChecksum.begin(); _iter873 != this->filesAddedChecksum.end(); ++_iter873)
+ {
+ xfer += oprot->writeString((*_iter873));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.subDirectoryList) {
+ xfer += oprot->writeFieldBegin("subDirectoryList", ::apache::thrift::protocol::T_LIST, 4);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->subDirectoryList.size()));
+ std::vector<std::string> ::const_iterator _iter874;
+ for (_iter874 = this->subDirectoryList.begin(); _iter874 != this->subDirectoryList.end(); ++_iter874)
{
- xfer += oprot->writeString((*_iter860));
+ xfer += oprot->writeString((*_iter874));
}
xfer += oprot->writeListEnd();
}
@@ -22046,20 +22350,23 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) {
swap(a.replace, b.replace);
swap(a.filesAdded, b.filesAdded);
swap(a.filesAddedChecksum, b.filesAddedChecksum);
+ swap(a.subDirectoryList, b.subDirectoryList);
swap(a.__isset, b.__isset);
}
-InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other861) {
- replace = other861.replace;
- filesAdded = other861.filesAdded;
- filesAddedChecksum = other861.filesAddedChecksum;
- __isset = other861.__isset;
+InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other875) {
+ replace = other875.replace;
+ filesAdded = other875.filesAdded;
+ filesAddedChecksum = other875.filesAddedChecksum;
+ subDirectoryList = other875.subDirectoryList;
+ __isset = other875.__isset;
}
-InsertEventRequest
<TRUNCATED>