You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by sp...@apache.org on 2016/05/06 20:42:49 UTC
[18/50] [abbrv] hive git commit: HIVE-13351: Support drop Primary
Key/Foreign Key constraints (Hari Subramaniyan, reviewed by Ashutosh Chauhan)
http://git-wip-us.apache.org/repos/asf/hive/blob/212077b8/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 8da883d..36a0f96 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -8999,6 +8999,138 @@ void ForeignKeysResponse::printTo(std::ostream& out) const {
}
+DropConstraintRequest::~DropConstraintRequest() throw() {
+}
+
+
+void DropConstraintRequest::__set_dbname(const std::string& val) {
+ this->dbname = val;
+}
+
+void DropConstraintRequest::__set_tablename(const std::string& val) {
+ this->tablename = val;
+}
+
+void DropConstraintRequest::__set_constraintname(const std::string& val) {
+ this->constraintname = val;
+}
+
+uint32_t DropConstraintRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_dbname = false;
+ bool isset_tablename = false;
+ bool isset_constraintname = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbname);
+ isset_dbname = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tablename);
+ isset_tablename = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->constraintname);
+ isset_constraintname = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbname)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tablename)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_constraintname)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t DropConstraintRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("DropConstraintRequest");
+
+ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbname);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tablename);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("constraintname", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->constraintname);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(DropConstraintRequest &a, DropConstraintRequest &b) {
+ using ::std::swap;
+ swap(a.dbname, b.dbname);
+ swap(a.tablename, b.tablename);
+ swap(a.constraintname, b.constraintname);
+}
+
+DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& other377) {
+ dbname = other377.dbname;
+ tablename = other377.tablename;
+ constraintname = other377.constraintname;
+}
+DropConstraintRequest& DropConstraintRequest::operator=(const DropConstraintRequest& other378) {
+ dbname = other378.dbname;
+ tablename = other378.tablename;
+ constraintname = other378.constraintname;
+ return *this;
+}
+void DropConstraintRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "DropConstraintRequest(";
+ out << "dbname=" << to_string(dbname);
+ out << ", " << "tablename=" << to_string(tablename);
+ out << ", " << "constraintname=" << to_string(constraintname);
+ out << ")";
+}
+
+
PartitionsByExprResult::~PartitionsByExprResult() throw() {
}
@@ -9038,14 +9170,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size377;
- ::apache::thrift::protocol::TType _etype380;
- xfer += iprot->readListBegin(_etype380, _size377);
- this->partitions.resize(_size377);
- uint32_t _i381;
- for (_i381 = 0; _i381 < _size377; ++_i381)
+ uint32_t _size379;
+ ::apache::thrift::protocol::TType _etype382;
+ xfer += iprot->readListBegin(_etype382, _size379);
+ this->partitions.resize(_size379);
+ uint32_t _i383;
+ for (_i383 = 0; _i383 < _size379; ++_i383)
{
- xfer += this->partitions[_i381].read(iprot);
+ xfer += this->partitions[_i383].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9086,10 +9218,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter382;
- for (_iter382 = this->partitions.begin(); _iter382 != this->partitions.end(); ++_iter382)
+ std::vector<Partition> ::const_iterator _iter384;
+ for (_iter384 = this->partitions.begin(); _iter384 != this->partitions.end(); ++_iter384)
{
- xfer += (*_iter382).write(oprot);
+ xfer += (*_iter384).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9110,13 +9242,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) {
swap(a.hasUnknownPartitions, b.hasUnknownPartitions);
}
-PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other383) {
- partitions = other383.partitions;
- hasUnknownPartitions = other383.hasUnknownPartitions;
+PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other385) {
+ partitions = other385.partitions;
+ hasUnknownPartitions = other385.hasUnknownPartitions;
}
-PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other384) {
- partitions = other384.partitions;
- hasUnknownPartitions = other384.hasUnknownPartitions;
+PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other386) {
+ partitions = other386.partitions;
+ hasUnknownPartitions = other386.hasUnknownPartitions;
return *this;
}
void PartitionsByExprResult::printTo(std::ostream& out) const {
@@ -9278,21 +9410,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) {
swap(a.__isset, b.__isset);
}
-PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other385) {
- dbName = other385.dbName;
- tblName = other385.tblName;
- expr = other385.expr;
- defaultPartitionName = other385.defaultPartitionName;
- maxParts = other385.maxParts;
- __isset = other385.__isset;
-}
-PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other386) {
- dbName = other386.dbName;
- tblName = other386.tblName;
- expr = other386.expr;
- defaultPartitionName = other386.defaultPartitionName;
- maxParts = other386.maxParts;
- __isset = other386.__isset;
+PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other387) {
+ dbName = other387.dbName;
+ tblName = other387.tblName;
+ expr = other387.expr;
+ defaultPartitionName = other387.defaultPartitionName;
+ maxParts = other387.maxParts;
+ __isset = other387.__isset;
+}
+PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other388) {
+ dbName = other388.dbName;
+ tblName = other388.tblName;
+ expr = other388.expr;
+ defaultPartitionName = other388.defaultPartitionName;
+ maxParts = other388.maxParts;
+ __isset = other388.__isset;
return *this;
}
void PartitionsByExprRequest::printTo(std::ostream& out) const {
@@ -9341,14 +9473,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tableStats.clear();
- uint32_t _size387;
- ::apache::thrift::protocol::TType _etype390;
- xfer += iprot->readListBegin(_etype390, _size387);
- this->tableStats.resize(_size387);
- uint32_t _i391;
- for (_i391 = 0; _i391 < _size387; ++_i391)
+ uint32_t _size389;
+ ::apache::thrift::protocol::TType _etype392;
+ xfer += iprot->readListBegin(_etype392, _size389);
+ this->tableStats.resize(_size389);
+ uint32_t _i393;
+ for (_i393 = 0; _i393 < _size389; ++_i393)
{
- xfer += this->tableStats[_i391].read(iprot);
+ xfer += this->tableStats[_i393].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9379,10 +9511,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tableStats.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter392;
- for (_iter392 = this->tableStats.begin(); _iter392 != this->tableStats.end(); ++_iter392)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter394;
+ for (_iter394 = this->tableStats.begin(); _iter394 != this->tableStats.end(); ++_iter394)
{
- xfer += (*_iter392).write(oprot);
+ xfer += (*_iter394).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9398,11 +9530,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) {
swap(a.tableStats, b.tableStats);
}
-TableStatsResult::TableStatsResult(const TableStatsResult& other393) {
- tableStats = other393.tableStats;
+TableStatsResult::TableStatsResult(const TableStatsResult& other395) {
+ tableStats = other395.tableStats;
}
-TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other394) {
- tableStats = other394.tableStats;
+TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other396) {
+ tableStats = other396.tableStats;
return *this;
}
void TableStatsResult::printTo(std::ostream& out) const {
@@ -9447,26 +9579,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->partStats.clear();
- uint32_t _size395;
- ::apache::thrift::protocol::TType _ktype396;
- ::apache::thrift::protocol::TType _vtype397;
- xfer += iprot->readMapBegin(_ktype396, _vtype397, _size395);
- uint32_t _i399;
- for (_i399 = 0; _i399 < _size395; ++_i399)
+ uint32_t _size397;
+ ::apache::thrift::protocol::TType _ktype398;
+ ::apache::thrift::protocol::TType _vtype399;
+ xfer += iprot->readMapBegin(_ktype398, _vtype399, _size397);
+ uint32_t _i401;
+ for (_i401 = 0; _i401 < _size397; ++_i401)
{
- std::string _key400;
- xfer += iprot->readString(_key400);
- std::vector<ColumnStatisticsObj> & _val401 = this->partStats[_key400];
+ std::string _key402;
+ xfer += iprot->readString(_key402);
+ std::vector<ColumnStatisticsObj> & _val403 = this->partStats[_key402];
{
- _val401.clear();
- uint32_t _size402;
- ::apache::thrift::protocol::TType _etype405;
- xfer += iprot->readListBegin(_etype405, _size402);
- _val401.resize(_size402);
- uint32_t _i406;
- for (_i406 = 0; _i406 < _size402; ++_i406)
+ _val403.clear();
+ uint32_t _size404;
+ ::apache::thrift::protocol::TType _etype407;
+ xfer += iprot->readListBegin(_etype407, _size404);
+ _val403.resize(_size404);
+ uint32_t _i408;
+ for (_i408 = 0; _i408 < _size404; ++_i408)
{
- xfer += _val401[_i406].read(iprot);
+ xfer += _val403[_i408].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9500,16 +9632,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr
xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1);
{
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->partStats.size()));
- std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter407;
- for (_iter407 = this->partStats.begin(); _iter407 != this->partStats.end(); ++_iter407)
+ std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter409;
+ for (_iter409 = this->partStats.begin(); _iter409 != this->partStats.end(); ++_iter409)
{
- xfer += oprot->writeString(_iter407->first);
+ xfer += oprot->writeString(_iter409->first);
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter407->second.size()));
- std::vector<ColumnStatisticsObj> ::const_iterator _iter408;
- for (_iter408 = _iter407->second.begin(); _iter408 != _iter407->second.end(); ++_iter408)
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter409->second.size()));
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter410;
+ for (_iter410 = _iter409->second.begin(); _iter410 != _iter409->second.end(); ++_iter410)
{
- xfer += (*_iter408).write(oprot);
+ xfer += (*_iter410).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9528,11 +9660,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) {
swap(a.partStats, b.partStats);
}
-PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other409) {
- partStats = other409.partStats;
+PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other411) {
+ partStats = other411.partStats;
}
-PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other410) {
- partStats = other410.partStats;
+PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other412) {
+ partStats = other412.partStats;
return *this;
}
void PartitionsStatsResult::printTo(std::ostream& out) const {
@@ -9603,14 +9735,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- uint32_t _size411;
- ::apache::thrift::protocol::TType _etype414;
- xfer += iprot->readListBegin(_etype414, _size411);
- this->colNames.resize(_size411);
- uint32_t _i415;
- for (_i415 = 0; _i415 < _size411; ++_i415)
+ uint32_t _size413;
+ ::apache::thrift::protocol::TType _etype416;
+ xfer += iprot->readListBegin(_etype416, _size413);
+ this->colNames.resize(_size413);
+ uint32_t _i417;
+ for (_i417 = 0; _i417 < _size413; ++_i417)
{
- xfer += iprot->readString(this->colNames[_i415]);
+ xfer += iprot->readString(this->colNames[_i417]);
}
xfer += iprot->readListEnd();
}
@@ -9653,10 +9785,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot)
xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size()));
- std::vector<std::string> ::const_iterator _iter416;
- for (_iter416 = this->colNames.begin(); _iter416 != this->colNames.end(); ++_iter416)
+ std::vector<std::string> ::const_iterator _iter418;
+ for (_iter418 = this->colNames.begin(); _iter418 != this->colNames.end(); ++_iter418)
{
- xfer += oprot->writeString((*_iter416));
+ xfer += oprot->writeString((*_iter418));
}
xfer += oprot->writeListEnd();
}
@@ -9674,15 +9806,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) {
swap(a.colNames, b.colNames);
}
-TableStatsRequest::TableStatsRequest(const TableStatsRequest& other417) {
- dbName = other417.dbName;
- tblName = other417.tblName;
- colNames = other417.colNames;
+TableStatsRequest::TableStatsRequest(const TableStatsRequest& other419) {
+ dbName = other419.dbName;
+ tblName = other419.tblName;
+ colNames = other419.colNames;
}
-TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other418) {
- dbName = other418.dbName;
- tblName = other418.tblName;
- colNames = other418.colNames;
+TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other420) {
+ dbName = other420.dbName;
+ tblName = other420.tblName;
+ colNames = other420.colNames;
return *this;
}
void TableStatsRequest::printTo(std::ostream& out) const {
@@ -9760,14 +9892,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- uint32_t _size419;
- ::apache::thrift::protocol::TType _etype422;
- xfer += iprot->readListBegin(_etype422, _size419);
- this->colNames.resize(_size419);
- uint32_t _i423;
- for (_i423 = 0; _i423 < _size419; ++_i423)
+ uint32_t _size421;
+ ::apache::thrift::protocol::TType _etype424;
+ xfer += iprot->readListBegin(_etype424, _size421);
+ this->colNames.resize(_size421);
+ uint32_t _i425;
+ for (_i425 = 0; _i425 < _size421; ++_i425)
{
- xfer += iprot->readString(this->colNames[_i423]);
+ xfer += iprot->readString(this->colNames[_i425]);
}
xfer += iprot->readListEnd();
}
@@ -9780,14 +9912,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- uint32_t _size424;
- ::apache::thrift::protocol::TType _etype427;
- xfer += iprot->readListBegin(_etype427, _size424);
- this->partNames.resize(_size424);
- uint32_t _i428;
- for (_i428 = 0; _i428 < _size424; ++_i428)
+ uint32_t _size426;
+ ::apache::thrift::protocol::TType _etype429;
+ xfer += iprot->readListBegin(_etype429, _size426);
+ this->partNames.resize(_size426);
+ uint32_t _i430;
+ for (_i430 = 0; _i430 < _size426; ++_i430)
{
- xfer += iprot->readString(this->partNames[_i428]);
+ xfer += iprot->readString(this->partNames[_i430]);
}
xfer += iprot->readListEnd();
}
@@ -9832,10 +9964,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size()));
- std::vector<std::string> ::const_iterator _iter429;
- for (_iter429 = this->colNames.begin(); _iter429 != this->colNames.end(); ++_iter429)
+ std::vector<std::string> ::const_iterator _iter431;
+ for (_iter431 = this->colNames.begin(); _iter431 != this->colNames.end(); ++_iter431)
{
- xfer += oprot->writeString((*_iter429));
+ xfer += oprot->writeString((*_iter431));
}
xfer += oprot->writeListEnd();
}
@@ -9844,10 +9976,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op
xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size()));
- std::vector<std::string> ::const_iterator _iter430;
- for (_iter430 = this->partNames.begin(); _iter430 != this->partNames.end(); ++_iter430)
+ std::vector<std::string> ::const_iterator _iter432;
+ for (_iter432 = this->partNames.begin(); _iter432 != this->partNames.end(); ++_iter432)
{
- xfer += oprot->writeString((*_iter430));
+ xfer += oprot->writeString((*_iter432));
}
xfer += oprot->writeListEnd();
}
@@ -9866,17 +9998,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) {
swap(a.partNames, b.partNames);
}
-PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other431) {
- dbName = other431.dbName;
- tblName = other431.tblName;
- colNames = other431.colNames;
- partNames = other431.partNames;
+PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other433) {
+ dbName = other433.dbName;
+ tblName = other433.tblName;
+ colNames = other433.colNames;
+ partNames = other433.partNames;
}
-PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other432) {
- dbName = other432.dbName;
- tblName = other432.tblName;
- colNames = other432.colNames;
- partNames = other432.partNames;
+PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other434) {
+ dbName = other434.dbName;
+ tblName = other434.tblName;
+ colNames = other434.colNames;
+ partNames = other434.partNames;
return *this;
}
void PartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -9924,14 +10056,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size433;
- ::apache::thrift::protocol::TType _etype436;
- xfer += iprot->readListBegin(_etype436, _size433);
- this->partitions.resize(_size433);
- uint32_t _i437;
- for (_i437 = 0; _i437 < _size433; ++_i437)
+ uint32_t _size435;
+ ::apache::thrift::protocol::TType _etype438;
+ xfer += iprot->readListBegin(_etype438, _size435);
+ this->partitions.resize(_size435);
+ uint32_t _i439;
+ for (_i439 = 0; _i439 < _size435; ++_i439)
{
- xfer += this->partitions[_i437].read(iprot);
+ xfer += this->partitions[_i439].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9961,10 +10093,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter438;
- for (_iter438 = this->partitions.begin(); _iter438 != this->partitions.end(); ++_iter438)
+ std::vector<Partition> ::const_iterator _iter440;
+ for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440)
{
- xfer += (*_iter438).write(oprot);
+ xfer += (*_iter440).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9981,13 +10113,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) {
swap(a.__isset, b.__isset);
}
-AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other439) {
- partitions = other439.partitions;
- __isset = other439.__isset;
+AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other441) {
+ partitions = other441.partitions;
+ __isset = other441.__isset;
}
-AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other440) {
- partitions = other440.partitions;
- __isset = other440.__isset;
+AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other442) {
+ partitions = other442.partitions;
+ __isset = other442.__isset;
return *this;
}
void AddPartitionsResult::printTo(std::ostream& out) const {
@@ -10068,14 +10200,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->parts.clear();
- uint32_t _size441;
- ::apache::thrift::protocol::TType _etype444;
- xfer += iprot->readListBegin(_etype444, _size441);
- this->parts.resize(_size441);
- uint32_t _i445;
- for (_i445 = 0; _i445 < _size441; ++_i445)
+ uint32_t _size443;
+ ::apache::thrift::protocol::TType _etype446;
+ xfer += iprot->readListBegin(_etype446, _size443);
+ this->parts.resize(_size443);
+ uint32_t _i447;
+ for (_i447 = 0; _i447 < _size443; ++_i447)
{
- xfer += this->parts[_i445].read(iprot);
+ xfer += this->parts[_i447].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10136,10 +10268,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->parts.size()));
- std::vector<Partition> ::const_iterator _iter446;
- for (_iter446 = this->parts.begin(); _iter446 != this->parts.end(); ++_iter446)
+ std::vector<Partition> ::const_iterator _iter448;
+ for (_iter448 = this->parts.begin(); _iter448 != this->parts.end(); ++_iter448)
{
- xfer += (*_iter446).write(oprot);
+ xfer += (*_iter448).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10169,21 +10301,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) {
swap(a.__isset, b.__isset);
}
-AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other447) {
- dbName = other447.dbName;
- tblName = other447.tblName;
- parts = other447.parts;
- ifNotExists = other447.ifNotExists;
- needResult = other447.needResult;
- __isset = other447.__isset;
-}
-AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other448) {
- dbName = other448.dbName;
- tblName = other448.tblName;
- parts = other448.parts;
- ifNotExists = other448.ifNotExists;
- needResult = other448.needResult;
- __isset = other448.__isset;
+AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other449) {
+ dbName = other449.dbName;
+ tblName = other449.tblName;
+ parts = other449.parts;
+ ifNotExists = other449.ifNotExists;
+ needResult = other449.needResult;
+ __isset = other449.__isset;
+}
+AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other450) {
+ dbName = other450.dbName;
+ tblName = other450.tblName;
+ parts = other450.parts;
+ ifNotExists = other450.ifNotExists;
+ needResult = other450.needResult;
+ __isset = other450.__isset;
return *this;
}
void AddPartitionsRequest::printTo(std::ostream& out) const {
@@ -10232,14 +10364,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- uint32_t _size449;
- ::apache::thrift::protocol::TType _etype452;
- xfer += iprot->readListBegin(_etype452, _size449);
- this->partitions.resize(_size449);
- uint32_t _i453;
- for (_i453 = 0; _i453 < _size449; ++_i453)
+ uint32_t _size451;
+ ::apache::thrift::protocol::TType _etype454;
+ xfer += iprot->readListBegin(_etype454, _size451);
+ this->partitions.resize(_size451);
+ uint32_t _i455;
+ for (_i455 = 0; _i455 < _size451; ++_i455)
{
- xfer += this->partitions[_i453].read(iprot);
+ xfer += this->partitions[_i455].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10269,10 +10401,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
- std::vector<Partition> ::const_iterator _iter454;
- for (_iter454 = this->partitions.begin(); _iter454 != this->partitions.end(); ++_iter454)
+ std::vector<Partition> ::const_iterator _iter456;
+ for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456)
{
- xfer += (*_iter454).write(oprot);
+ xfer += (*_iter456).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10289,13 +10421,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) {
swap(a.__isset, b.__isset);
}
-DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other455) {
- partitions = other455.partitions;
- __isset = other455.__isset;
+DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other457) {
+ partitions = other457.partitions;
+ __isset = other457.__isset;
}
-DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other456) {
- partitions = other456.partitions;
- __isset = other456.__isset;
+DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other458) {
+ partitions = other458.partitions;
+ __isset = other458.__isset;
return *this;
}
void DropPartitionsResult::printTo(std::ostream& out) const {
@@ -10397,15 +10529,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) {
swap(a.__isset, b.__isset);
}
-DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other457) {
- expr = other457.expr;
- partArchiveLevel = other457.partArchiveLevel;
- __isset = other457.__isset;
+DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other459) {
+ expr = other459.expr;
+ partArchiveLevel = other459.partArchiveLevel;
+ __isset = other459.__isset;
}
-DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other458) {
- expr = other458.expr;
- partArchiveLevel = other458.partArchiveLevel;
- __isset = other458.__isset;
+DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other460) {
+ expr = other460.expr;
+ partArchiveLevel = other460.partArchiveLevel;
+ __isset = other460.__isset;
return *this;
}
void DropPartitionsExpr::printTo(std::ostream& out) const {
@@ -10454,14 +10586,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->names.clear();
- uint32_t _size459;
- ::apache::thrift::protocol::TType _etype462;
- xfer += iprot->readListBegin(_etype462, _size459);
- this->names.resize(_size459);
- uint32_t _i463;
- for (_i463 = 0; _i463 < _size459; ++_i463)
+ uint32_t _size461;
+ ::apache::thrift::protocol::TType _etype464;
+ xfer += iprot->readListBegin(_etype464, _size461);
+ this->names.resize(_size461);
+ uint32_t _i465;
+ for (_i465 = 0; _i465 < _size461; ++_i465)
{
- xfer += iprot->readString(this->names[_i463]);
+ xfer += iprot->readString(this->names[_i465]);
}
xfer += iprot->readListEnd();
}
@@ -10474,14 +10606,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->exprs.clear();
- uint32_t _size464;
- ::apache::thrift::protocol::TType _etype467;
- xfer += iprot->readListBegin(_etype467, _size464);
- this->exprs.resize(_size464);
- uint32_t _i468;
- for (_i468 = 0; _i468 < _size464; ++_i468)
+ uint32_t _size466;
+ ::apache::thrift::protocol::TType _etype469;
+ xfer += iprot->readListBegin(_etype469, _size466);
+ this->exprs.resize(_size466);
+ uint32_t _i470;
+ for (_i470 = 0; _i470 < _size466; ++_i470)
{
- xfer += this->exprs[_i468].read(iprot);
+ xfer += this->exprs[_i470].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10510,10 +10642,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size()));
- std::vector<std::string> ::const_iterator _iter469;
- for (_iter469 = this->names.begin(); _iter469 != this->names.end(); ++_iter469)
+ std::vector<std::string> ::const_iterator _iter471;
+ for (_iter471 = this->names.begin(); _iter471 != this->names.end(); ++_iter471)
{
- xfer += oprot->writeString((*_iter469));
+ xfer += oprot->writeString((*_iter471));
}
xfer += oprot->writeListEnd();
}
@@ -10522,10 +10654,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->exprs.size()));
- std::vector<DropPartitionsExpr> ::const_iterator _iter470;
- for (_iter470 = this->exprs.begin(); _iter470 != this->exprs.end(); ++_iter470)
+ std::vector<DropPartitionsExpr> ::const_iterator _iter472;
+ for (_iter472 = this->exprs.begin(); _iter472 != this->exprs.end(); ++_iter472)
{
- xfer += (*_iter470).write(oprot);
+ xfer += (*_iter472).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10543,15 +10675,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) {
swap(a.__isset, b.__isset);
}
-RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other471) {
- names = other471.names;
- exprs = other471.exprs;
- __isset = other471.__isset;
+RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other473) {
+ names = other473.names;
+ exprs = other473.exprs;
+ __isset = other473.__isset;
}
-RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other472) {
- names = other472.names;
- exprs = other472.exprs;
- __isset = other472.__isset;
+RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other474) {
+ names = other474.names;
+ exprs = other474.exprs;
+ __isset = other474.__isset;
return *this;
}
void RequestPartsSpec::printTo(std::ostream& out) const {
@@ -10770,27 +10902,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) {
swap(a.__isset, b.__isset);
}
-DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other473) {
- dbName = other473.dbName;
- tblName = other473.tblName;
- parts = other473.parts;
- deleteData = other473.deleteData;
- ifExists = other473.ifExists;
- ignoreProtection = other473.ignoreProtection;
- environmentContext = other473.environmentContext;
- needResult = other473.needResult;
- __isset = other473.__isset;
-}
-DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other474) {
- dbName = other474.dbName;
- tblName = other474.tblName;
- parts = other474.parts;
- deleteData = other474.deleteData;
- ifExists = other474.ifExists;
- ignoreProtection = other474.ignoreProtection;
- environmentContext = other474.environmentContext;
- needResult = other474.needResult;
- __isset = other474.__isset;
+DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other475) {
+ dbName = other475.dbName;
+ tblName = other475.tblName;
+ parts = other475.parts;
+ deleteData = other475.deleteData;
+ ifExists = other475.ifExists;
+ ignoreProtection = other475.ignoreProtection;
+ environmentContext = other475.environmentContext;
+ needResult = other475.needResult;
+ __isset = other475.__isset;
+}
+DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other476) {
+ dbName = other476.dbName;
+ tblName = other476.tblName;
+ parts = other476.parts;
+ deleteData = other476.deleteData;
+ ifExists = other476.ifExists;
+ ignoreProtection = other476.ignoreProtection;
+ environmentContext = other476.environmentContext;
+ needResult = other476.needResult;
+ __isset = other476.__isset;
return *this;
}
void DropPartitionsRequest::printTo(std::ostream& out) const {
@@ -10843,9 +10975,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast475;
- xfer += iprot->readI32(ecast475);
- this->resourceType = (ResourceType::type)ecast475;
+ int32_t ecast477;
+ xfer += iprot->readI32(ecast477);
+ this->resourceType = (ResourceType::type)ecast477;
this->__isset.resourceType = true;
} else {
xfer += iprot->skip(ftype);
@@ -10896,15 +11028,15 @@ void swap(ResourceUri &a, ResourceUri &b) {
swap(a.__isset, b.__isset);
}
-ResourceUri::ResourceUri(const ResourceUri& other476) {
- resourceType = other476.resourceType;
- uri = other476.uri;
- __isset = other476.__isset;
+ResourceUri::ResourceUri(const ResourceUri& other478) {
+ resourceType = other478.resourceType;
+ uri = other478.uri;
+ __isset = other478.__isset;
}
-ResourceUri& ResourceUri::operator=(const ResourceUri& other477) {
- resourceType = other477.resourceType;
- uri = other477.uri;
- __isset = other477.__isset;
+ResourceUri& ResourceUri::operator=(const ResourceUri& other479) {
+ resourceType = other479.resourceType;
+ uri = other479.uri;
+ __isset = other479.__isset;
return *this;
}
void ResourceUri::printTo(std::ostream& out) const {
@@ -11007,9 +11139,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast478;
- xfer += iprot->readI32(ecast478);
- this->ownerType = (PrincipalType::type)ecast478;
+ int32_t ecast480;
+ xfer += iprot->readI32(ecast480);
+ this->ownerType = (PrincipalType::type)ecast480;
this->__isset.ownerType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11025,9 +11157,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 7:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast479;
- xfer += iprot->readI32(ecast479);
- this->functionType = (FunctionType::type)ecast479;
+ int32_t ecast481;
+ xfer += iprot->readI32(ecast481);
+ this->functionType = (FunctionType::type)ecast481;
this->__isset.functionType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11037,14 +11169,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->resourceUris.clear();
- uint32_t _size480;
- ::apache::thrift::protocol::TType _etype483;
- xfer += iprot->readListBegin(_etype483, _size480);
- this->resourceUris.resize(_size480);
- uint32_t _i484;
- for (_i484 = 0; _i484 < _size480; ++_i484)
+ uint32_t _size482;
+ ::apache::thrift::protocol::TType _etype485;
+ xfer += iprot->readListBegin(_etype485, _size482);
+ this->resourceUris.resize(_size482);
+ uint32_t _i486;
+ for (_i486 = 0; _i486 < _size482; ++_i486)
{
- xfer += this->resourceUris[_i484].read(iprot);
+ xfer += this->resourceUris[_i486].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11101,10 +11233,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const {
xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->resourceUris.size()));
- std::vector<ResourceUri> ::const_iterator _iter485;
- for (_iter485 = this->resourceUris.begin(); _iter485 != this->resourceUris.end(); ++_iter485)
+ std::vector<ResourceUri> ::const_iterator _iter487;
+ for (_iter487 = this->resourceUris.begin(); _iter487 != this->resourceUris.end(); ++_iter487)
{
- xfer += (*_iter485).write(oprot);
+ xfer += (*_iter487).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11128,27 +11260,27 @@ void swap(Function &a, Function &b) {
swap(a.__isset, b.__isset);
}
-Function::Function(const Function& other486) {
- functionName = other486.functionName;
- dbName = other486.dbName;
- className = other486.className;
- ownerName = other486.ownerName;
- ownerType = other486.ownerType;
- createTime = other486.createTime;
- functionType = other486.functionType;
- resourceUris = other486.resourceUris;
- __isset = other486.__isset;
-}
-Function& Function::operator=(const Function& other487) {
- functionName = other487.functionName;
- dbName = other487.dbName;
- className = other487.className;
- ownerName = other487.ownerName;
- ownerType = other487.ownerType;
- createTime = other487.createTime;
- functionType = other487.functionType;
- resourceUris = other487.resourceUris;
- __isset = other487.__isset;
+Function::Function(const Function& other488) {
+ functionName = other488.functionName;
+ dbName = other488.dbName;
+ className = other488.className;
+ ownerName = other488.ownerName;
+ ownerType = other488.ownerType;
+ createTime = other488.createTime;
+ functionType = other488.functionType;
+ resourceUris = other488.resourceUris;
+ __isset = other488.__isset;
+}
+Function& Function::operator=(const Function& other489) {
+ functionName = other489.functionName;
+ dbName = other489.dbName;
+ className = other489.className;
+ ownerName = other489.ownerName;
+ ownerType = other489.ownerType;
+ createTime = other489.createTime;
+ functionType = other489.functionType;
+ resourceUris = other489.resourceUris;
+ __isset = other489.__isset;
return *this;
}
void Function::printTo(std::ostream& out) const {
@@ -11236,9 +11368,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast488;
- xfer += iprot->readI32(ecast488);
- this->state = (TxnState::type)ecast488;
+ int32_t ecast490;
+ xfer += iprot->readI32(ecast490);
+ this->state = (TxnState::type)ecast490;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -11357,25 +11489,25 @@ void swap(TxnInfo &a, TxnInfo &b) {
swap(a.__isset, b.__isset);
}
-TxnInfo::TxnInfo(const TxnInfo& other489) {
- id = other489.id;
- state = other489.state;
- user = other489.user;
- hostname = other489.hostname;
- agentInfo = other489.agentInfo;
- heartbeatCount = other489.heartbeatCount;
- metaInfo = other489.metaInfo;
- __isset = other489.__isset;
-}
-TxnInfo& TxnInfo::operator=(const TxnInfo& other490) {
- id = other490.id;
- state = other490.state;
- user = other490.user;
- hostname = other490.hostname;
- agentInfo = other490.agentInfo;
- heartbeatCount = other490.heartbeatCount;
- metaInfo = other490.metaInfo;
- __isset = other490.__isset;
+TxnInfo::TxnInfo(const TxnInfo& other491) {
+ id = other491.id;
+ state = other491.state;
+ user = other491.user;
+ hostname = other491.hostname;
+ agentInfo = other491.agentInfo;
+ heartbeatCount = other491.heartbeatCount;
+ metaInfo = other491.metaInfo;
+ __isset = other491.__isset;
+}
+TxnInfo& TxnInfo::operator=(const TxnInfo& other492) {
+ id = other492.id;
+ state = other492.state;
+ user = other492.user;
+ hostname = other492.hostname;
+ agentInfo = other492.agentInfo;
+ heartbeatCount = other492.heartbeatCount;
+ metaInfo = other492.metaInfo;
+ __isset = other492.__isset;
return *this;
}
void TxnInfo::printTo(std::ostream& out) const {
@@ -11439,14 +11571,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- uint32_t _size491;
- ::apache::thrift::protocol::TType _etype494;
- xfer += iprot->readListBegin(_etype494, _size491);
- this->open_txns.resize(_size491);
- uint32_t _i495;
- for (_i495 = 0; _i495 < _size491; ++_i495)
+ uint32_t _size493;
+ ::apache::thrift::protocol::TType _etype496;
+ xfer += iprot->readListBegin(_etype496, _size493);
+ this->open_txns.resize(_size493);
+ uint32_t _i497;
+ for (_i497 = 0; _i497 < _size493; ++_i497)
{
- xfer += this->open_txns[_i495].read(iprot);
+ xfer += this->open_txns[_i497].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11483,10 +11615,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->open_txns.size()));
- std::vector<TxnInfo> ::const_iterator _iter496;
- for (_iter496 = this->open_txns.begin(); _iter496 != this->open_txns.end(); ++_iter496)
+ std::vector<TxnInfo> ::const_iterator _iter498;
+ for (_iter498 = this->open_txns.begin(); _iter498 != this->open_txns.end(); ++_iter498)
{
- xfer += (*_iter496).write(oprot);
+ xfer += (*_iter498).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11503,13 +11635,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other497) {
- txn_high_water_mark = other497.txn_high_water_mark;
- open_txns = other497.open_txns;
+GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other499) {
+ txn_high_water_mark = other499.txn_high_water_mark;
+ open_txns = other499.open_txns;
}
-GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other498) {
- txn_high_water_mark = other498.txn_high_water_mark;
- open_txns = other498.open_txns;
+GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other500) {
+ txn_high_water_mark = other500.txn_high_water_mark;
+ open_txns = other500.open_txns;
return *this;
}
void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const {
@@ -11568,15 +11700,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->open_txns.clear();
- uint32_t _size499;
- ::apache::thrift::protocol::TType _etype502;
- xfer += iprot->readSetBegin(_etype502, _size499);
- uint32_t _i503;
- for (_i503 = 0; _i503 < _size499; ++_i503)
+ uint32_t _size501;
+ ::apache::thrift::protocol::TType _etype504;
+ xfer += iprot->readSetBegin(_etype504, _size501);
+ uint32_t _i505;
+ for (_i505 = 0; _i505 < _size501; ++_i505)
{
- int64_t _elem504;
- xfer += iprot->readI64(_elem504);
- this->open_txns.insert(_elem504);
+ int64_t _elem506;
+ xfer += iprot->readI64(_elem506);
+ this->open_txns.insert(_elem506);
}
xfer += iprot->readSetEnd();
}
@@ -11613,10 +11745,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2);
{
xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
- std::set<int64_t> ::const_iterator _iter505;
- for (_iter505 = this->open_txns.begin(); _iter505 != this->open_txns.end(); ++_iter505)
+ std::set<int64_t> ::const_iterator _iter507;
+ for (_iter507 = this->open_txns.begin(); _iter507 != this->open_txns.end(); ++_iter507)
{
- xfer += oprot->writeI64((*_iter505));
+ xfer += oprot->writeI64((*_iter507));
}
xfer += oprot->writeSetEnd();
}
@@ -11633,13 +11765,13 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other506) {
- txn_high_water_mark = other506.txn_high_water_mark;
- open_txns = other506.open_txns;
+GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other508) {
+ txn_high_water_mark = other508.txn_high_water_mark;
+ open_txns = other508.open_txns;
}
-GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other507) {
- txn_high_water_mark = other507.txn_high_water_mark;
- open_txns = other507.open_txns;
+GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other509) {
+ txn_high_water_mark = other509.txn_high_water_mark;
+ open_txns = other509.open_txns;
return *this;
}
void GetOpenTxnsResponse::printTo(std::ostream& out) const {
@@ -11782,19 +11914,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) {
swap(a.__isset, b.__isset);
}
-OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other508) {
- num_txns = other508.num_txns;
- user = other508.user;
- hostname = other508.hostname;
- agentInfo = other508.agentInfo;
- __isset = other508.__isset;
+OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other510) {
+ num_txns = other510.num_txns;
+ user = other510.user;
+ hostname = other510.hostname;
+ agentInfo = other510.agentInfo;
+ __isset = other510.__isset;
}
-OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other509) {
- num_txns = other509.num_txns;
- user = other509.user;
- hostname = other509.hostname;
- agentInfo = other509.agentInfo;
- __isset = other509.__isset;
+OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other511) {
+ num_txns = other511.num_txns;
+ user = other511.user;
+ hostname = other511.hostname;
+ agentInfo = other511.agentInfo;
+ __isset = other511.__isset;
return *this;
}
void OpenTxnRequest::printTo(std::ostream& out) const {
@@ -11842,14 +11974,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size510;
- ::apache::thrift::protocol::TType _etype513;
- xfer += iprot->readListBegin(_etype513, _size510);
- this->txn_ids.resize(_size510);
- uint32_t _i514;
- for (_i514 = 0; _i514 < _size510; ++_i514)
+ uint32_t _size512;
+ ::apache::thrift::protocol::TType _etype515;
+ xfer += iprot->readListBegin(_etype515, _size512);
+ this->txn_ids.resize(_size512);
+ uint32_t _i516;
+ for (_i516 = 0; _i516 < _size512; ++_i516)
{
- xfer += iprot->readI64(this->txn_ids[_i514]);
+ xfer += iprot->readI64(this->txn_ids[_i516]);
}
xfer += iprot->readListEnd();
}
@@ -11880,10 +12012,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter515;
- for (_iter515 = this->txn_ids.begin(); _iter515 != this->txn_ids.end(); ++_iter515)
+ std::vector<int64_t> ::const_iterator _iter517;
+ for (_iter517 = this->txn_ids.begin(); _iter517 != this->txn_ids.end(); ++_iter517)
{
- xfer += oprot->writeI64((*_iter515));
+ xfer += oprot->writeI64((*_iter517));
}
xfer += oprot->writeListEnd();
}
@@ -11899,11 +12031,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) {
swap(a.txn_ids, b.txn_ids);
}
-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other516) {
- txn_ids = other516.txn_ids;
+OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other518) {
+ txn_ids = other518.txn_ids;
}
-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other517) {
- txn_ids = other517.txn_ids;
+OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other519) {
+ txn_ids = other519.txn_ids;
return *this;
}
void OpenTxnsResponse::printTo(std::ostream& out) const {
@@ -11985,11 +12117,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other518) {
- txnid = other518.txnid;
+AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other520) {
+ txnid = other520.txnid;
}
-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other519) {
- txnid = other519.txnid;
+AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other521) {
+ txnid = other521.txnid;
return *this;
}
void AbortTxnRequest::printTo(std::ostream& out) const {
@@ -12071,11 +12203,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other520) {
- txnid = other520.txnid;
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other522) {
+ txnid = other522.txnid;
}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other521) {
- txnid = other521.txnid;
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other523) {
+ txnid = other523.txnid;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -12138,9 +12270,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast522;
- xfer += iprot->readI32(ecast522);
- this->type = (LockType::type)ecast522;
+ int32_t ecast524;
+ xfer += iprot->readI32(ecast524);
+ this->type = (LockType::type)ecast524;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12148,9 +12280,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast523;
- xfer += iprot->readI32(ecast523);
- this->level = (LockLevel::type)ecast523;
+ int32_t ecast525;
+ xfer += iprot->readI32(ecast525);
+ this->level = (LockLevel::type)ecast525;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -12240,21 +12372,21 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other524) {
- type = other524.type;
- level = other524.level;
- dbname = other524.dbname;
- tablename = other524.tablename;
- partitionname = other524.partitionname;
- __isset = other524.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other525) {
- type = other525.type;
- level = other525.level;
- dbname = other525.dbname;
- tablename = other525.tablename;
- partitionname = other525.partitionname;
- __isset = other525.__isset;
+LockComponent::LockComponent(const LockComponent& other526) {
+ type = other526.type;
+ level = other526.level;
+ dbname = other526.dbname;
+ tablename = other526.tablename;
+ partitionname = other526.partitionname;
+ __isset = other526.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other527) {
+ type = other527.type;
+ level = other527.level;
+ dbname = other527.dbname;
+ tablename = other527.tablename;
+ partitionname = other527.partitionname;
+ __isset = other527.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -12323,14 +12455,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size526;
- ::apache::thrift::protocol::TType _etype529;
- xfer += iprot->readListBegin(_etype529, _size526);
- this->component.resize(_size526);
- uint32_t _i530;
- for (_i530 = 0; _i530 < _size526; ++_i530)
+ uint32_t _size528;
+ ::apache::thrift::protocol::TType _etype531;
+ xfer += iprot->readListBegin(_etype531, _size528);
+ this->component.resize(_size528);
+ uint32_t _i532;
+ for (_i532 = 0; _i532 < _size528; ++_i532)
{
- xfer += this->component[_i530].read(iprot);
+ xfer += this->component[_i532].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12397,10 +12529,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 _iter531;
- for (_iter531 = this->component.begin(); _iter531 != this->component.end(); ++_iter531)
+ std::vector<LockComponent> ::const_iterator _iter533;
+ for (_iter533 = this->component.begin(); _iter533 != this->component.end(); ++_iter533)
{
- xfer += (*_iter531).write(oprot);
+ xfer += (*_iter533).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12439,21 +12571,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other532) {
- component = other532.component;
- txnid = other532.txnid;
- user = other532.user;
- hostname = other532.hostname;
- agentInfo = other532.agentInfo;
- __isset = other532.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other533) {
- component = other533.component;
- txnid = other533.txnid;
- user = other533.user;
- hostname = other533.hostname;
- agentInfo = other533.agentInfo;
- __isset = other533.__isset;
+LockRequest::LockRequest(const LockRequest& other534) {
+ component = other534.component;
+ txnid = other534.txnid;
+ user = other534.user;
+ hostname = other534.hostname;
+ agentInfo = other534.agentInfo;
+ __isset = other534.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other535) {
+ component = other535.component;
+ txnid = other535.txnid;
+ user = other535.user;
+ hostname = other535.hostname;
+ agentInfo = other535.agentInfo;
+ __isset = other535.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -12513,9 +12645,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast534;
- xfer += iprot->readI32(ecast534);
- this->state = (LockState::type)ecast534;
+ int32_t ecast536;
+ xfer += iprot->readI32(ecast536);
+ this->state = (LockState::type)ecast536;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -12561,13 +12693,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other535) {
- lockid = other535.lockid;
- state = other535.state;
+LockResponse::LockResponse(const LockResponse& other537) {
+ lockid = other537.lockid;
+ state = other537.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other536) {
- lockid = other536.lockid;
- state = other536.state;
+LockResponse& LockResponse::operator=(const LockResponse& other538) {
+ lockid = other538.lockid;
+ state = other538.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -12689,17 +12821,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other537) {
- lockid = other537.lockid;
- txnid = other537.txnid;
- elapsed_ms = other537.elapsed_ms;
- __isset = other537.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other539) {
+ lockid = other539.lockid;
+ txnid = other539.txnid;
+ elapsed_ms = other539.elapsed_ms;
+ __isset = other539.__isset;
}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other538) {
- lockid = other538.lockid;
- txnid = other538.txnid;
- elapsed_ms = other538.elapsed_ms;
- __isset = other538.__isset;
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other540) {
+ lockid = other540.lockid;
+ txnid = other540.txnid;
+ elapsed_ms = other540.elapsed_ms;
+ __isset = other540.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -12783,11 +12915,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other539) {
- lockid = other539.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other541) {
+ lockid = other541.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other540) {
- lockid = other540.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other542) {
+ lockid = other542.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -12926,19 +13058,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other541) {
- dbname = other541.dbname;
- tablename = other541.tablename;
- partname = other541.partname;
- isExtended = other541.isExtended;
- __isset = other541.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other543) {
+ dbname = other543.dbname;
+ tablename = other543.tablename;
+ partname = other543.partname;
+ isExtended = other543.isExtended;
+ __isset = other543.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other542) {
- dbname = other542.dbname;
- tablename = other542.tablename;
- partname = other542.partname;
- isExtended = other542.isExtended;
- __isset = other542.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other544) {
+ dbname = other544.dbname;
+ tablename = other544.tablename;
+ partname = other544.partname;
+ isExtended = other544.isExtended;
+ __isset = other544.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -13091,9 +13223,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast543;
- xfer += iprot->readI32(ecast543);
- this->state = (LockState::type)ecast543;
+ int32_t ecast545;
+ xfer += iprot->readI32(ecast545);
+ this->state = (LockState::type)ecast545;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13101,9 +13233,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast544;
- xfer += iprot->readI32(ecast544);
- this->type = (LockType::type)ecast544;
+ int32_t ecast546;
+ xfer += iprot->readI32(ecast546);
+ this->type = (LockType::type)ecast546;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13319,43 +13451,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other545) {
- lockid = other545.lockid;
- dbname = other545.dbname;
- tablename = other545.tablename;
- partname = other545.partname;
- state = other545.state;
- type = other545.type;
- txnid = other545.txnid;
- lastheartbeat = other545.lastheartbeat;
- acquiredat = other545.acquiredat;
- user = other545.user;
- hostname = other545.hostname;
- heartbeatCount = other545.heartbeatCount;
- agentInfo = other545.agentInfo;
- blockedByExtId = other545.blockedByExtId;
- blockedByIntId = other545.blockedByIntId;
- lockIdInternal = other545.lockIdInternal;
- __isset = other545.__isset;
-}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other546) {
- lockid = other546.lockid;
- dbname = other546.dbname;
- tablename = other546.tablename;
- partname = other546.partname;
- state = other546.state;
- type = other546.type;
- txnid = other546.txnid;
- lastheartbeat = other546.lastheartbeat;
- acquiredat = other546.acquiredat;
- user = other546.user;
- hostname = other546.hostname;
- heartbeatCount = other546.heartbeatCount;
- agentInfo = other546.agentInfo;
- blockedByExtId = other546.blockedByExtId;
- blockedByIntId = other546.blockedByIntId;
- lockIdInternal = other546.lockIdInternal;
- __isset = other546.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other547) {
+ lockid = other547.lockid;
+ dbname = other547.dbname;
+ tablename = other547.tablename;
+ partname = other547.partname;
+ state = other547.state;
+ type = other547.type;
+ txnid = other547.txnid;
+ lastheartbeat = other547.lastheartbeat;
+ acquiredat = other547.acquiredat;
+ user = other547.user;
+ hostname = other547.hostname;
+ heartbeatCount = other547.heartbeatCount;
+ agentInfo = other547.agentInfo;
+ blockedByExtId = other547.blockedByExtId;
+ blockedByIntId = other547.blockedByIntId;
+ lockIdInternal = other547.lockIdInternal;
+ __isset = other547.__isset;
+}
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other548) {
+ lockid = other548.lockid;
+ dbname = other548.dbname;
+ tablename = other548.tablename;
+ partname = other548.partname;
+ state = other548.state;
+ type = other548.type;
+ txnid = other548.txnid;
+ lastheartbeat = other548.lastheartbeat;
+ acquiredat = other548.acquiredat;
+ user = other548.user;
+ hostname = other548.hostname;
+ heartbeatCount = other548.heartbeatCount;
+ agentInfo = other548.agentInfo;
+ blockedByExtId = other548.blockedByExtId;
+ blockedByIntId = other548.blockedByIntId;
+ lockIdInternal = other548.lockIdInternal;
+ __isset = other548.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -13414,14 +13546,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size547;
- ::apache::thrift::protocol::TType _etype550;
- xfer += iprot->readListBegin(_etype550, _size547);
- this->locks.resize(_size547);
- uint32_t _i551;
- for (_i551 = 0; _i551 < _size547; ++_i551)
+ uint32_t _size549;
+ ::apache::thrift::protocol::TType _etype552;
+ xfer += iprot->readListBegin(_etype552, _size549);
+ this->locks.resize(_size549);
+ uint32_t _i553;
+ for (_i553 = 0; _i553 < _size549; ++_i553)
{
- xfer += this->locks[_i551].read(iprot);
+ xfer += this->locks[_i553].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -13450,10 +13582,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 _iter552;
- for (_iter552 = this->locks.begin(); _iter552 != this->locks.end(); ++_iter552)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter554;
+ for (_iter554 = this->locks.begin(); _iter554 != this->locks.end(); ++_iter554)
{
- xfer += (*_iter552).write(oprot);
+ xfer += (*_iter554).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13470,13 +13602,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other553) {
- locks = other553.locks;
- __isset = other553.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other555) {
+ locks = other555.locks;
+ __isset = other555.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other554) {
- locks = other554.locks;
- __isset = other554.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other556) {
+ locks = other556.locks;
+ __isset = other556.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -13577,15 +13709,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other555) {
- lockid = other555.lockid;
- txnid = other555.txnid;
- __isset = other555.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other557) {
+ lockid = other557.lockid;
+ txnid = other557.txnid;
+ __isset = other557.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other556) {
- lockid = other556.lockid;
- txnid = other556.txnid;
- __isset = other556.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other558) {
+ lockid = other558.lockid;
+ txnid = other558.txnid;
+ __isset = other558.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -13688,13 +13820,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other557) {
- min = other557.min;
- max = other557.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other559) {
+ min = other559.min;
+ max = other559.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other558) {
- min = other558.min;
- max = other558.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other560) {
+ min = other560.min;
+ max = other560.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -13745,15 +13877,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size559;
- ::apache::thrift::protocol::TType _etype562;
- xfer += iprot->readSetBegin(_etype562, _size559);
- uint32_t _i563;
- for (_i563 = 0; _i563 < _size559; ++_i563)
+ uint32_t _size561;
+ ::apache::thrift::protocol::TType _etype564;
+ xfer += iprot->readSetBegin(_etype564, _size561);
+ uint32_t _i565;
+ for (_i565 = 0; _i565 < _size561; ++_i565)
{
- int64_t _elem564;
- xfer += iprot->readI64(_elem564);
- this->aborted.insert(_elem564);
+ int64_t _elem566;
+ xfer += iprot->readI64(_elem566);
+ this->aborted.insert(_elem566);
}
xfer += iprot->readSetEnd();
}
@@ -13766,15 +13898,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size565;
- ::apache::thrift::protocol::TType _etype568;
- xfer += iprot->readSetBegin(_etype568, _size565);
- uint32_t _i569;
- for (_i569 = 0; _i569 < _size565; ++_i569)
+ uint32_t _size567;
+ ::apache::thrift::protocol::TType _etype570;
+ xfer += iprot->readSetBegin(_etype570, _size567);
+ uint32_t _i571;
+ for (_i571 = 0; _i571 < _size567; ++_i571)
{
- int64_t _elem570;
- xfer += iprot->readI64(_elem570);
- this->nosuch.insert(_elem570);
+ int64_t _elem572;
+ xfer += iprot->readI64(_elem572);
+ this->nosuch.insert(_elem572);
}
xfer += iprot->readSetEnd();
}
@@ -13807,10 +13939,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 _iter571;
- for (_iter571 = this->aborted.begin(); _iter571 != this->aborted.end(); ++_iter571)
+ std::set<int64_t> ::const_iterator _iter573;
+ for (_iter573 = this->aborted.begin(); _iter573 != this->aborted.end(); ++_iter573)
{
- xfer += oprot->writeI64((*_iter571));
+ xfer += oprot->writeI64((*_iter573));
}
xfer += oprot->writeSetEnd();
}
@@ -13819,10 +13951,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 _iter572;
- for (_iter572 = this->nosuch.begin(); _iter572 != this->nosuch.end(); ++_iter572)
+ std::set<int64_t> ::const_iterator _iter574;
+ for (_iter574 = this->nosuch.begin(); _iter574 != this->nosuch.end(); ++_iter574)
{
- xfer += oprot->writeI64((*_iter572));
+ xfer += oprot->writeI64((*_iter574));
}
xfer += oprot->writeSetEnd();
}
@@ -13839,13 +13971,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other573) {
- aborted = other573.aborted;
- nosuch = other573.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other575) {
+ aborted = other575.aborted;
+ nosuch = other575.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other574) {
- aborted = other574.aborted;
- nosuch = other574.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other576) {
+ aborted = other576.aborted;
+ nosuch = other576.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -13933,9 +14065,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast575;
- xfer += iprot->readI32(ecast575);
- this->type = (CompactionType::type)ecast575;
+ int32_t ecast577;
+ xfer += iprot->readI32(ecast577);
+ this->type = (CompactionType::type)ecast577;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14009,21 +14141,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other576) {
- dbname = other576.dbname;
- tablename = other576.tablename;
- partitionname = other576.partitionname;
- type = other576.type;
- runas = other576.runas;
- __isset = other576.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other577) {
- dbname = other577.dbname;
- tablename = other577.tablename;
- partitionname = other577.partitionname;
- type = other577.type;
- runas = other577.runas;
- __isset = other577.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other578) {
+ dbname = other578.dbname;
+ tablename = other578.tablename;
+ partitionname = other578.partitionname;
+ type = other578.type;
+ runas = other578.runas;
+ __isset = other578.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other579) {
+ dbname = other579.dbname;
+ tablename = other579.tablename;
+ partitionname = other579.partitionname;
+ type = other579.type;
+ runas = other579.runas;
+ __isset = other579.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -14086,11 +14218,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other578) {
- (void) other578;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other580) {
+ (void) other580;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other579) {
- (void) other579;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other581) {
+ (void) other581;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -14211,9 +14343,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast580;
- xfer += iprot->readI32(ecast580);
- this->type = (CompactionType::type)ecast580;
+ int32_t ecast582;
+ xfer += iprot->readI32(ecast582);
+ this->type = (CompactionType::type)ecast582;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14386,35 +14518,35 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other581) {
- dbname = other581.dbname;
- tablename = other581.tablename;
- partitionname = other581.partitionname;
- type = other581.type;
- state = other581.state;
- workerid = other581.workerid;
- start = other581.start;
- runAs = other581.runAs;
- hightestTxnId = other581.hightestTxnId;
- metaInfo = other581.metaInfo;
- endTime = other581.endTime;
- hadoopJobId = other581.hadoopJobId;
- __isset = other581.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other582) {
- dbname = other582.dbname;
- tablename = other582.tablename;
- partitionname = other582.partitionname;
- type = other582.type;
- state = other582.state;
- workerid = other582.workerid;
- start = other582.start;
- runAs = other582.runAs;
- hightestTxnId = other582.hightestTxnId;
- metaInfo = other582.metaInfo;
- endTime = other582.endTime;
- hadoopJobId = other582.hadoopJobId;
- __isset = other582.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other583) {
+ dbname = other583.dbname;
+ tablename = other583.tablename;
+ partitionname = other583.partitionname;
+ type = other583.type;
+ state = other583.state;
+ workerid = other583.workerid;
+ start = other583.start;
+ runAs = other583.runAs;
+ hightestTxnId = other583.hightestTxnId;
+ metaInfo = other583.metaInfo;
+ endTime = other583.endTime;
+ hadoopJobId = other583.hadoopJobId;
+ __isset = other583.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other584) {
+ dbname = other584.dbname;
+ tablename = other584.tablename;
+ partitionname = other584.partitionname;
+ type = other584.type;
+ state = other584.state;
+ workerid = other584.workerid;
+ start = other584.start;
+ runAs = other584.runAs;
+ hightestTxnId = other584.hightestTxnId;
+ metaInfo = other584.metaInfo;
+ endTime = other584.endTime;
+ hadoopJobId = other584.hadoopJobId;
+ __isset = other584.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -14470,14 +14602,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size583;
- ::apache::thrift::protocol::TType _etype586;
- xfer += iprot->readListBegin(_etype586, _size583);
- this->compacts.resize(_size583);
- uint32_t _i587;
- for (_i587 = 0; _i587 < _size583; ++_i587)
+ uint32_t _size585;
+ ::apache::thrift::protocol::TType _etype588;
+ xfer += iprot->readListBegin(_etype588, _size585);
+ this->compacts.resize(_size585);
+ uint32_t _i589;
+ for (_i589 = 0; _i589 < _size585; ++_i589)
{
- xfer += this->compacts[_i587].read(iprot);
+ xfer += this->compacts[_i589].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -14508,10 +14640,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 _iter588;
- for (_iter588 = this->compacts.begin(); _iter588 != this->compacts.end(); ++_iter588)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter590;
+ for (_iter590 = this->compacts.begin(); _iter590 != this->compacts.end(); ++_iter590)
{
- xfer += (*_iter588).write(oprot);
+ xfer += (*_iter590).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -14527,11 +14659,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other589) {
- compacts = other589.compacts;
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other591) {
+ compacts = other591.compacts;
}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other590) {
- compacts = other590.compacts;
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other592) {
+ compacts = other592.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -14615,14 +14747,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- uint32_t _size591;
- ::apache::thrift::protocol::TType _etype594;
- xfer += iprot->readListBegin(_etype594, _size591);
- this->partitionnames.resize(_size591);
- uint32_t _i595;
- for (_i595 = 0; _i595 < _size591; ++_i595)
+ uint32_t _size593;
+ ::apache::thrift::protocol::TType _etype596;
+ xfer += iprot->readListBegin(_etype596, _size593);
+ this->partitionnames.resize(_size593);
+ uint32_t _i597;
+ for (_i597 = 0; _i597 < _size593; ++_i597)
{
- xfer += iprot->readString(this->partitionnames[_i595]);
+ xfer += iprot->readString(this->partitionnames[_i597]);
}
xfer += iprot->readListEnd();
}
@@ -14671,10 +14803,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionnames.size()));
- std::vector<std::string> ::const_iterator _iter596;
- for (_iter596 = this->partitionnames.begin(); _iter596 != this->partitionnames.end(); ++_iter596)
+ std::vector<std::string> ::const_iterator _iter598;
+ for (_iter598 = this->partitionnames.begin(); _iter598 != this->partitionnames.end(); ++_iter598)
{
- xfer += oprot->writeString((*_iter596));
+ xfer += oprot->writeString((*_iter598));
}
xfer += oprot->writeListEnd();
}
@@ -14693,17 +14825,17 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.partitionnames, b.partitionnames);
}
-AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other597) {
- txnid = other597.txnid;
- dbname = other597.dbname;
- tablename = other597.tablename;
- partitionnames = other597.partitionnames;
+AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other599) {
+ txnid = other599.txnid;
+ dbname = other599.dbname;
+ tablename = other599.tablename;
+ partitionnames = other599.partitionnames;
}
-AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other598) {
- txnid = other598.txnid;
- dbname = other598.dbname;
- tablename = other598.tablename;
- partitionnames = other598.partitionnames;
+AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other600) {
+ txnid = other600.txnid;
+ dbname = other600.dbname;
+ tablename = other600.tablename;
+ partitionnames = other600.partitionnames;
return *this;
}
void AddDynamicPartitions::printTo(std::ostream& out) const {
@@ -14808,15 +14940,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other599) {
- lastEvent = other599.lastEvent;
- maxEvents = other599.maxEvents;
- __isset = other599.__isset;
+NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other601) {
+ lastEvent = other601.lastEvent;
+ maxEvents = other601.maxEvents;
+ __isset = other601.__isset;
}
-NotificationEventRequest& NotificationEventRequest::operator=(const No
<TRUNCATED>