You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ha...@apache.org on 2016/05/11 20:31:39 UTC
[09/12] hive git commit: HIVE-13350: Support Alter commands for
Rely/NoRely novalidate for PK/FK constraints (Hari Subramaniyan,
reviewed by Ashutosh Chauhan)
http://git-wip-us.apache.org/repos/asf/hive/blob/b36f6a3a/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 d0c24de..ad5da3e 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -9122,6 +9122,218 @@ void DropConstraintRequest::printTo(std::ostream& out) const {
}
+AddPrimaryKeyRequest::~AddPrimaryKeyRequest() throw() {
+}
+
+
+void AddPrimaryKeyRequest::__set_primaryKeyCols(const std::vector<SQLPrimaryKey> & val) {
+ this->primaryKeyCols = val;
+}
+
+uint32_t AddPrimaryKeyRequest::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_primaryKeyCols = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->primaryKeyCols.clear();
+ uint32_t _size379;
+ ::apache::thrift::protocol::TType _etype382;
+ xfer += iprot->readListBegin(_etype382, _size379);
+ this->primaryKeyCols.resize(_size379);
+ uint32_t _i383;
+ for (_i383 = 0; _i383 < _size379; ++_i383)
+ {
+ xfer += this->primaryKeyCols[_i383].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_primaryKeyCols = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_primaryKeyCols)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("AddPrimaryKeyRequest");
+
+ xfer += oprot->writeFieldBegin("primaryKeyCols", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeyCols.size()));
+ std::vector<SQLPrimaryKey> ::const_iterator _iter384;
+ for (_iter384 = this->primaryKeyCols.begin(); _iter384 != this->primaryKeyCols.end(); ++_iter384)
+ {
+ xfer += (*_iter384).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AddPrimaryKeyRequest &a, AddPrimaryKeyRequest &b) {
+ using ::std::swap;
+ swap(a.primaryKeyCols, b.primaryKeyCols);
+}
+
+AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& other385) {
+ primaryKeyCols = other385.primaryKeyCols;
+}
+AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const AddPrimaryKeyRequest& other386) {
+ primaryKeyCols = other386.primaryKeyCols;
+ return *this;
+}
+void AddPrimaryKeyRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "AddPrimaryKeyRequest(";
+ out << "primaryKeyCols=" << to_string(primaryKeyCols);
+ out << ")";
+}
+
+
+AddForeignKeyRequest::~AddForeignKeyRequest() throw() {
+}
+
+
+void AddForeignKeyRequest::__set_foreignKeyCols(const std::vector<SQLForeignKey> & val) {
+ this->foreignKeyCols = val;
+}
+
+uint32_t AddForeignKeyRequest::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_foreignKeyCols = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->foreignKeyCols.clear();
+ uint32_t _size387;
+ ::apache::thrift::protocol::TType _etype390;
+ xfer += iprot->readListBegin(_etype390, _size387);
+ this->foreignKeyCols.resize(_size387);
+ uint32_t _i391;
+ for (_i391 = 0; _i391 < _size387; ++_i391)
+ {
+ xfer += this->foreignKeyCols[_i391].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_foreignKeyCols = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_foreignKeyCols)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("AddForeignKeyRequest");
+
+ xfer += oprot->writeFieldBegin("foreignKeyCols", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeyCols.size()));
+ std::vector<SQLForeignKey> ::const_iterator _iter392;
+ for (_iter392 = this->foreignKeyCols.begin(); _iter392 != this->foreignKeyCols.end(); ++_iter392)
+ {
+ xfer += (*_iter392).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(AddForeignKeyRequest &a, AddForeignKeyRequest &b) {
+ using ::std::swap;
+ swap(a.foreignKeyCols, b.foreignKeyCols);
+}
+
+AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& other393) {
+ foreignKeyCols = other393.foreignKeyCols;
+}
+AddForeignKeyRequest& AddForeignKeyRequest::operator=(const AddForeignKeyRequest& other394) {
+ foreignKeyCols = other394.foreignKeyCols;
+ return *this;
+}
+void AddForeignKeyRequest::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "AddForeignKeyRequest(";
+ out << "foreignKeyCols=" << to_string(foreignKeyCols);
+ out << ")";
+}
+
+
PartitionsByExprResult::~PartitionsByExprResult() throw() {
}
@@ -9161,14 +9373,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- 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)
+ uint32_t _size395;
+ ::apache::thrift::protocol::TType _etype398;
+ xfer += iprot->readListBegin(_etype398, _size395);
+ this->partitions.resize(_size395);
+ uint32_t _i399;
+ for (_i399 = 0; _i399 < _size395; ++_i399)
{
- xfer += this->partitions[_i383].read(iprot);
+ xfer += this->partitions[_i399].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9209,10 +9421,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 _iter384;
- for (_iter384 = this->partitions.begin(); _iter384 != this->partitions.end(); ++_iter384)
+ std::vector<Partition> ::const_iterator _iter400;
+ for (_iter400 = this->partitions.begin(); _iter400 != this->partitions.end(); ++_iter400)
{
- xfer += (*_iter384).write(oprot);
+ xfer += (*_iter400).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9233,13 +9445,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) {
swap(a.hasUnknownPartitions, b.hasUnknownPartitions);
}
-PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other385) {
- partitions = other385.partitions;
- hasUnknownPartitions = other385.hasUnknownPartitions;
+PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other401) {
+ partitions = other401.partitions;
+ hasUnknownPartitions = other401.hasUnknownPartitions;
}
-PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other386) {
- partitions = other386.partitions;
- hasUnknownPartitions = other386.hasUnknownPartitions;
+PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other402) {
+ partitions = other402.partitions;
+ hasUnknownPartitions = other402.hasUnknownPartitions;
return *this;
}
void PartitionsByExprResult::printTo(std::ostream& out) const {
@@ -9401,21 +9613,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) {
swap(a.__isset, b.__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;
+PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other403) {
+ dbName = other403.dbName;
+ tblName = other403.tblName;
+ expr = other403.expr;
+ defaultPartitionName = other403.defaultPartitionName;
+ maxParts = other403.maxParts;
+ __isset = other403.__isset;
+}
+PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other404) {
+ dbName = other404.dbName;
+ tblName = other404.tblName;
+ expr = other404.expr;
+ defaultPartitionName = other404.defaultPartitionName;
+ maxParts = other404.maxParts;
+ __isset = other404.__isset;
return *this;
}
void PartitionsByExprRequest::printTo(std::ostream& out) const {
@@ -9464,14 +9676,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tableStats.clear();
- 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)
+ uint32_t _size405;
+ ::apache::thrift::protocol::TType _etype408;
+ xfer += iprot->readListBegin(_etype408, _size405);
+ this->tableStats.resize(_size405);
+ uint32_t _i409;
+ for (_i409 = 0; _i409 < _size405; ++_i409)
{
- xfer += this->tableStats[_i393].read(iprot);
+ xfer += this->tableStats[_i409].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9502,10 +9714,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 _iter394;
- for (_iter394 = this->tableStats.begin(); _iter394 != this->tableStats.end(); ++_iter394)
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter410;
+ for (_iter410 = this->tableStats.begin(); _iter410 != this->tableStats.end(); ++_iter410)
{
- xfer += (*_iter394).write(oprot);
+ xfer += (*_iter410).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9521,11 +9733,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) {
swap(a.tableStats, b.tableStats);
}
-TableStatsResult::TableStatsResult(const TableStatsResult& other395) {
- tableStats = other395.tableStats;
+TableStatsResult::TableStatsResult(const TableStatsResult& other411) {
+ tableStats = other411.tableStats;
}
-TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other396) {
- tableStats = other396.tableStats;
+TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other412) {
+ tableStats = other412.tableStats;
return *this;
}
void TableStatsResult::printTo(std::ostream& out) const {
@@ -9570,26 +9782,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->partStats.clear();
- 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)
+ uint32_t _size413;
+ ::apache::thrift::protocol::TType _ktype414;
+ ::apache::thrift::protocol::TType _vtype415;
+ xfer += iprot->readMapBegin(_ktype414, _vtype415, _size413);
+ uint32_t _i417;
+ for (_i417 = 0; _i417 < _size413; ++_i417)
{
- std::string _key402;
- xfer += iprot->readString(_key402);
- std::vector<ColumnStatisticsObj> & _val403 = this->partStats[_key402];
+ std::string _key418;
+ xfer += iprot->readString(_key418);
+ std::vector<ColumnStatisticsObj> & _val419 = this->partStats[_key418];
{
- _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)
+ _val419.clear();
+ uint32_t _size420;
+ ::apache::thrift::protocol::TType _etype423;
+ xfer += iprot->readListBegin(_etype423, _size420);
+ _val419.resize(_size420);
+ uint32_t _i424;
+ for (_i424 = 0; _i424 < _size420; ++_i424)
{
- xfer += _val403[_i408].read(iprot);
+ xfer += _val419[_i424].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9623,16 +9835,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 _iter409;
- for (_iter409 = this->partStats.begin(); _iter409 != this->partStats.end(); ++_iter409)
+ std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter425;
+ for (_iter425 = this->partStats.begin(); _iter425 != this->partStats.end(); ++_iter425)
{
- xfer += oprot->writeString(_iter409->first);
+ xfer += oprot->writeString(_iter425->first);
{
- 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 += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter425->second.size()));
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter426;
+ for (_iter426 = _iter425->second.begin(); _iter426 != _iter425->second.end(); ++_iter426)
{
- xfer += (*_iter410).write(oprot);
+ xfer += (*_iter426).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -9651,11 +9863,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) {
swap(a.partStats, b.partStats);
}
-PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other411) {
- partStats = other411.partStats;
+PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other427) {
+ partStats = other427.partStats;
}
-PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other412) {
- partStats = other412.partStats;
+PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other428) {
+ partStats = other428.partStats;
return *this;
}
void PartitionsStatsResult::printTo(std::ostream& out) const {
@@ -9726,14 +9938,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- 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)
+ uint32_t _size429;
+ ::apache::thrift::protocol::TType _etype432;
+ xfer += iprot->readListBegin(_etype432, _size429);
+ this->colNames.resize(_size429);
+ uint32_t _i433;
+ for (_i433 = 0; _i433 < _size429; ++_i433)
{
- xfer += iprot->readString(this->colNames[_i417]);
+ xfer += iprot->readString(this->colNames[_i433]);
}
xfer += iprot->readListEnd();
}
@@ -9776,10 +9988,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 _iter418;
- for (_iter418 = this->colNames.begin(); _iter418 != this->colNames.end(); ++_iter418)
+ std::vector<std::string> ::const_iterator _iter434;
+ for (_iter434 = this->colNames.begin(); _iter434 != this->colNames.end(); ++_iter434)
{
- xfer += oprot->writeString((*_iter418));
+ xfer += oprot->writeString((*_iter434));
}
xfer += oprot->writeListEnd();
}
@@ -9797,15 +10009,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) {
swap(a.colNames, b.colNames);
}
-TableStatsRequest::TableStatsRequest(const TableStatsRequest& other419) {
- dbName = other419.dbName;
- tblName = other419.tblName;
- colNames = other419.colNames;
+TableStatsRequest::TableStatsRequest(const TableStatsRequest& other435) {
+ dbName = other435.dbName;
+ tblName = other435.tblName;
+ colNames = other435.colNames;
}
-TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other420) {
- dbName = other420.dbName;
- tblName = other420.tblName;
- colNames = other420.colNames;
+TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other436) {
+ dbName = other436.dbName;
+ tblName = other436.tblName;
+ colNames = other436.colNames;
return *this;
}
void TableStatsRequest::printTo(std::ostream& out) const {
@@ -9883,14 +10095,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->colNames.clear();
- 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)
+ uint32_t _size437;
+ ::apache::thrift::protocol::TType _etype440;
+ xfer += iprot->readListBegin(_etype440, _size437);
+ this->colNames.resize(_size437);
+ uint32_t _i441;
+ for (_i441 = 0; _i441 < _size437; ++_i441)
{
- xfer += iprot->readString(this->colNames[_i425]);
+ xfer += iprot->readString(this->colNames[_i441]);
}
xfer += iprot->readListEnd();
}
@@ -9903,14 +10115,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- 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)
+ uint32_t _size442;
+ ::apache::thrift::protocol::TType _etype445;
+ xfer += iprot->readListBegin(_etype445, _size442);
+ this->partNames.resize(_size442);
+ uint32_t _i446;
+ for (_i446 = 0; _i446 < _size442; ++_i446)
{
- xfer += iprot->readString(this->partNames[_i430]);
+ xfer += iprot->readString(this->partNames[_i446]);
}
xfer += iprot->readListEnd();
}
@@ -9955,10 +10167,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 _iter431;
- for (_iter431 = this->colNames.begin(); _iter431 != this->colNames.end(); ++_iter431)
+ std::vector<std::string> ::const_iterator _iter447;
+ for (_iter447 = this->colNames.begin(); _iter447 != this->colNames.end(); ++_iter447)
{
- xfer += oprot->writeString((*_iter431));
+ xfer += oprot->writeString((*_iter447));
}
xfer += oprot->writeListEnd();
}
@@ -9967,10 +10179,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 _iter432;
- for (_iter432 = this->partNames.begin(); _iter432 != this->partNames.end(); ++_iter432)
+ std::vector<std::string> ::const_iterator _iter448;
+ for (_iter448 = this->partNames.begin(); _iter448 != this->partNames.end(); ++_iter448)
{
- xfer += oprot->writeString((*_iter432));
+ xfer += oprot->writeString((*_iter448));
}
xfer += oprot->writeListEnd();
}
@@ -9989,17 +10201,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) {
swap(a.partNames, b.partNames);
}
-PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other433) {
- dbName = other433.dbName;
- tblName = other433.tblName;
- colNames = other433.colNames;
- partNames = other433.partNames;
+PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other449) {
+ dbName = other449.dbName;
+ tblName = other449.tblName;
+ colNames = other449.colNames;
+ partNames = other449.partNames;
}
-PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other434) {
- dbName = other434.dbName;
- tblName = other434.tblName;
- colNames = other434.colNames;
- partNames = other434.partNames;
+PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other450) {
+ dbName = other450.dbName;
+ tblName = other450.tblName;
+ colNames = other450.colNames;
+ partNames = other450.partNames;
return *this;
}
void PartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -10047,14 +10259,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- 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)
+ 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[_i439].read(iprot);
+ xfer += this->partitions[_i455].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10084,10 +10296,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 _iter440;
- for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440)
+ std::vector<Partition> ::const_iterator _iter456;
+ for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456)
{
- xfer += (*_iter440).write(oprot);
+ xfer += (*_iter456).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10104,13 +10316,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) {
swap(a.__isset, b.__isset);
}
-AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other441) {
- partitions = other441.partitions;
- __isset = other441.__isset;
+AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other457) {
+ partitions = other457.partitions;
+ __isset = other457.__isset;
}
-AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other442) {
- partitions = other442.partitions;
- __isset = other442.__isset;
+AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other458) {
+ partitions = other458.partitions;
+ __isset = other458.__isset;
return *this;
}
void AddPartitionsResult::printTo(std::ostream& out) const {
@@ -10191,14 +10403,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->parts.clear();
- 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)
+ uint32_t _size459;
+ ::apache::thrift::protocol::TType _etype462;
+ xfer += iprot->readListBegin(_etype462, _size459);
+ this->parts.resize(_size459);
+ uint32_t _i463;
+ for (_i463 = 0; _i463 < _size459; ++_i463)
{
- xfer += this->parts[_i447].read(iprot);
+ xfer += this->parts[_i463].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10259,10 +10471,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 _iter448;
- for (_iter448 = this->parts.begin(); _iter448 != this->parts.end(); ++_iter448)
+ std::vector<Partition> ::const_iterator _iter464;
+ for (_iter464 = this->parts.begin(); _iter464 != this->parts.end(); ++_iter464)
{
- xfer += (*_iter448).write(oprot);
+ xfer += (*_iter464).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10292,21 +10504,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) {
swap(a.__isset, b.__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;
+AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other465) {
+ dbName = other465.dbName;
+ tblName = other465.tblName;
+ parts = other465.parts;
+ ifNotExists = other465.ifNotExists;
+ needResult = other465.needResult;
+ __isset = other465.__isset;
+}
+AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other466) {
+ dbName = other466.dbName;
+ tblName = other466.tblName;
+ parts = other466.parts;
+ ifNotExists = other466.ifNotExists;
+ needResult = other466.needResult;
+ __isset = other466.__isset;
return *this;
}
void AddPartitionsRequest::printTo(std::ostream& out) const {
@@ -10355,14 +10567,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitions.clear();
- 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)
+ uint32_t _size467;
+ ::apache::thrift::protocol::TType _etype470;
+ xfer += iprot->readListBegin(_etype470, _size467);
+ this->partitions.resize(_size467);
+ uint32_t _i471;
+ for (_i471 = 0; _i471 < _size467; ++_i471)
{
- xfer += this->partitions[_i455].read(iprot);
+ xfer += this->partitions[_i471].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10392,10 +10604,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 _iter456;
- for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456)
+ std::vector<Partition> ::const_iterator _iter472;
+ for (_iter472 = this->partitions.begin(); _iter472 != this->partitions.end(); ++_iter472)
{
- xfer += (*_iter456).write(oprot);
+ xfer += (*_iter472).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10412,13 +10624,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) {
swap(a.__isset, b.__isset);
}
-DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other457) {
- partitions = other457.partitions;
- __isset = other457.__isset;
+DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other473) {
+ partitions = other473.partitions;
+ __isset = other473.__isset;
}
-DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other458) {
- partitions = other458.partitions;
- __isset = other458.__isset;
+DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other474) {
+ partitions = other474.partitions;
+ __isset = other474.__isset;
return *this;
}
void DropPartitionsResult::printTo(std::ostream& out) const {
@@ -10520,15 +10732,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) {
swap(a.__isset, b.__isset);
}
-DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other459) {
- expr = other459.expr;
- partArchiveLevel = other459.partArchiveLevel;
- __isset = other459.__isset;
+DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other475) {
+ expr = other475.expr;
+ partArchiveLevel = other475.partArchiveLevel;
+ __isset = other475.__isset;
}
-DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other460) {
- expr = other460.expr;
- partArchiveLevel = other460.partArchiveLevel;
- __isset = other460.__isset;
+DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other476) {
+ expr = other476.expr;
+ partArchiveLevel = other476.partArchiveLevel;
+ __isset = other476.__isset;
return *this;
}
void DropPartitionsExpr::printTo(std::ostream& out) const {
@@ -10577,14 +10789,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->names.clear();
- 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)
+ uint32_t _size477;
+ ::apache::thrift::protocol::TType _etype480;
+ xfer += iprot->readListBegin(_etype480, _size477);
+ this->names.resize(_size477);
+ uint32_t _i481;
+ for (_i481 = 0; _i481 < _size477; ++_i481)
{
- xfer += iprot->readString(this->names[_i465]);
+ xfer += iprot->readString(this->names[_i481]);
}
xfer += iprot->readListEnd();
}
@@ -10597,14 +10809,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->exprs.clear();
- 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)
+ uint32_t _size482;
+ ::apache::thrift::protocol::TType _etype485;
+ xfer += iprot->readListBegin(_etype485, _size482);
+ this->exprs.resize(_size482);
+ uint32_t _i486;
+ for (_i486 = 0; _i486 < _size482; ++_i486)
{
- xfer += this->exprs[_i470].read(iprot);
+ xfer += this->exprs[_i486].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -10633,10 +10845,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 _iter471;
- for (_iter471 = this->names.begin(); _iter471 != this->names.end(); ++_iter471)
+ std::vector<std::string> ::const_iterator _iter487;
+ for (_iter487 = this->names.begin(); _iter487 != this->names.end(); ++_iter487)
{
- xfer += oprot->writeString((*_iter471));
+ xfer += oprot->writeString((*_iter487));
}
xfer += oprot->writeListEnd();
}
@@ -10645,10 +10857,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 _iter472;
- for (_iter472 = this->exprs.begin(); _iter472 != this->exprs.end(); ++_iter472)
+ std::vector<DropPartitionsExpr> ::const_iterator _iter488;
+ for (_iter488 = this->exprs.begin(); _iter488 != this->exprs.end(); ++_iter488)
{
- xfer += (*_iter472).write(oprot);
+ xfer += (*_iter488).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -10666,15 +10878,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) {
swap(a.__isset, b.__isset);
}
-RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other473) {
- names = other473.names;
- exprs = other473.exprs;
- __isset = other473.__isset;
+RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other489) {
+ names = other489.names;
+ exprs = other489.exprs;
+ __isset = other489.__isset;
}
-RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other474) {
- names = other474.names;
- exprs = other474.exprs;
- __isset = other474.__isset;
+RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other490) {
+ names = other490.names;
+ exprs = other490.exprs;
+ __isset = other490.__isset;
return *this;
}
void RequestPartsSpec::printTo(std::ostream& out) const {
@@ -10893,27 +11105,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) {
swap(a.__isset, b.__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(const DropPartitionsRequest& other491) {
+ dbName = other491.dbName;
+ tblName = other491.tblName;
+ parts = other491.parts;
+ deleteData = other491.deleteData;
+ ifExists = other491.ifExists;
+ ignoreProtection = other491.ignoreProtection;
+ environmentContext = other491.environmentContext;
+ needResult = other491.needResult;
+ __isset = other491.__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;
+DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other492) {
+ dbName = other492.dbName;
+ tblName = other492.tblName;
+ parts = other492.parts;
+ deleteData = other492.deleteData;
+ ifExists = other492.ifExists;
+ ignoreProtection = other492.ignoreProtection;
+ environmentContext = other492.environmentContext;
+ needResult = other492.needResult;
+ __isset = other492.__isset;
return *this;
}
void DropPartitionsRequest::printTo(std::ostream& out) const {
@@ -10966,9 +11178,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast477;
- xfer += iprot->readI32(ecast477);
- this->resourceType = (ResourceType::type)ecast477;
+ int32_t ecast493;
+ xfer += iprot->readI32(ecast493);
+ this->resourceType = (ResourceType::type)ecast493;
this->__isset.resourceType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11019,15 +11231,15 @@ void swap(ResourceUri &a, ResourceUri &b) {
swap(a.__isset, b.__isset);
}
-ResourceUri::ResourceUri(const ResourceUri& other478) {
- resourceType = other478.resourceType;
- uri = other478.uri;
- __isset = other478.__isset;
+ResourceUri::ResourceUri(const ResourceUri& other494) {
+ resourceType = other494.resourceType;
+ uri = other494.uri;
+ __isset = other494.__isset;
}
-ResourceUri& ResourceUri::operator=(const ResourceUri& other479) {
- resourceType = other479.resourceType;
- uri = other479.uri;
- __isset = other479.__isset;
+ResourceUri& ResourceUri::operator=(const ResourceUri& other495) {
+ resourceType = other495.resourceType;
+ uri = other495.uri;
+ __isset = other495.__isset;
return *this;
}
void ResourceUri::printTo(std::ostream& out) const {
@@ -11130,9 +11342,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast480;
- xfer += iprot->readI32(ecast480);
- this->ownerType = (PrincipalType::type)ecast480;
+ int32_t ecast496;
+ xfer += iprot->readI32(ecast496);
+ this->ownerType = (PrincipalType::type)ecast496;
this->__isset.ownerType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11148,9 +11360,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 7:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast481;
- xfer += iprot->readI32(ecast481);
- this->functionType = (FunctionType::type)ecast481;
+ int32_t ecast497;
+ xfer += iprot->readI32(ecast497);
+ this->functionType = (FunctionType::type)ecast497;
this->__isset.functionType = true;
} else {
xfer += iprot->skip(ftype);
@@ -11160,14 +11372,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->resourceUris.clear();
- 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)
+ uint32_t _size498;
+ ::apache::thrift::protocol::TType _etype501;
+ xfer += iprot->readListBegin(_etype501, _size498);
+ this->resourceUris.resize(_size498);
+ uint32_t _i502;
+ for (_i502 = 0; _i502 < _size498; ++_i502)
{
- xfer += this->resourceUris[_i486].read(iprot);
+ xfer += this->resourceUris[_i502].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11224,10 +11436,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 _iter487;
- for (_iter487 = this->resourceUris.begin(); _iter487 != this->resourceUris.end(); ++_iter487)
+ std::vector<ResourceUri> ::const_iterator _iter503;
+ for (_iter503 = this->resourceUris.begin(); _iter503 != this->resourceUris.end(); ++_iter503)
{
- xfer += (*_iter487).write(oprot);
+ xfer += (*_iter503).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11251,27 +11463,27 @@ void swap(Function &a, Function &b) {
swap(a.__isset, b.__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;
+Function::Function(const Function& other504) {
+ functionName = other504.functionName;
+ dbName = other504.dbName;
+ className = other504.className;
+ ownerName = other504.ownerName;
+ ownerType = other504.ownerType;
+ createTime = other504.createTime;
+ functionType = other504.functionType;
+ resourceUris = other504.resourceUris;
+ __isset = other504.__isset;
+}
+Function& Function::operator=(const Function& other505) {
+ functionName = other505.functionName;
+ dbName = other505.dbName;
+ className = other505.className;
+ ownerName = other505.ownerName;
+ ownerType = other505.ownerType;
+ createTime = other505.createTime;
+ functionType = other505.functionType;
+ resourceUris = other505.resourceUris;
+ __isset = other505.__isset;
return *this;
}
void Function::printTo(std::ostream& out) const {
@@ -11359,9 +11571,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast490;
- xfer += iprot->readI32(ecast490);
- this->state = (TxnState::type)ecast490;
+ int32_t ecast506;
+ xfer += iprot->readI32(ecast506);
+ this->state = (TxnState::type)ecast506;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -11480,25 +11692,25 @@ void swap(TxnInfo &a, TxnInfo &b) {
swap(a.__isset, b.__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;
+TxnInfo::TxnInfo(const TxnInfo& other507) {
+ id = other507.id;
+ state = other507.state;
+ user = other507.user;
+ hostname = other507.hostname;
+ agentInfo = other507.agentInfo;
+ heartbeatCount = other507.heartbeatCount;
+ metaInfo = other507.metaInfo;
+ __isset = other507.__isset;
+}
+TxnInfo& TxnInfo::operator=(const TxnInfo& other508) {
+ id = other508.id;
+ state = other508.state;
+ user = other508.user;
+ hostname = other508.hostname;
+ agentInfo = other508.agentInfo;
+ heartbeatCount = other508.heartbeatCount;
+ metaInfo = other508.metaInfo;
+ __isset = other508.__isset;
return *this;
}
void TxnInfo::printTo(std::ostream& out) const {
@@ -11562,14 +11774,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->open_txns.clear();
- 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)
+ uint32_t _size509;
+ ::apache::thrift::protocol::TType _etype512;
+ xfer += iprot->readListBegin(_etype512, _size509);
+ this->open_txns.resize(_size509);
+ uint32_t _i513;
+ for (_i513 = 0; _i513 < _size509; ++_i513)
{
- xfer += this->open_txns[_i497].read(iprot);
+ xfer += this->open_txns[_i513].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11606,10 +11818,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 _iter498;
- for (_iter498 = this->open_txns.begin(); _iter498 != this->open_txns.end(); ++_iter498)
+ std::vector<TxnInfo> ::const_iterator _iter514;
+ for (_iter514 = this->open_txns.begin(); _iter514 != this->open_txns.end(); ++_iter514)
{
- xfer += (*_iter498).write(oprot);
+ xfer += (*_iter514).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11626,13 +11838,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other499) {
- txn_high_water_mark = other499.txn_high_water_mark;
- open_txns = other499.open_txns;
+GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other515) {
+ txn_high_water_mark = other515.txn_high_water_mark;
+ open_txns = other515.open_txns;
}
-GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other500) {
- txn_high_water_mark = other500.txn_high_water_mark;
- open_txns = other500.open_txns;
+GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other516) {
+ txn_high_water_mark = other516.txn_high_water_mark;
+ open_txns = other516.open_txns;
return *this;
}
void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const {
@@ -11691,15 +11903,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->open_txns.clear();
- uint32_t _size501;
- ::apache::thrift::protocol::TType _etype504;
- xfer += iprot->readSetBegin(_etype504, _size501);
- uint32_t _i505;
- for (_i505 = 0; _i505 < _size501; ++_i505)
+ uint32_t _size517;
+ ::apache::thrift::protocol::TType _etype520;
+ xfer += iprot->readSetBegin(_etype520, _size517);
+ uint32_t _i521;
+ for (_i521 = 0; _i521 < _size517; ++_i521)
{
- int64_t _elem506;
- xfer += iprot->readI64(_elem506);
- this->open_txns.insert(_elem506);
+ int64_t _elem522;
+ xfer += iprot->readI64(_elem522);
+ this->open_txns.insert(_elem522);
}
xfer += iprot->readSetEnd();
}
@@ -11736,10 +11948,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 _iter507;
- for (_iter507 = this->open_txns.begin(); _iter507 != this->open_txns.end(); ++_iter507)
+ std::set<int64_t> ::const_iterator _iter523;
+ for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523)
{
- xfer += oprot->writeI64((*_iter507));
+ xfer += oprot->writeI64((*_iter523));
}
xfer += oprot->writeSetEnd();
}
@@ -11756,13 +11968,13 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) {
swap(a.open_txns, b.open_txns);
}
-GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other508) {
- txn_high_water_mark = other508.txn_high_water_mark;
- open_txns = other508.open_txns;
+GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other524) {
+ txn_high_water_mark = other524.txn_high_water_mark;
+ open_txns = other524.open_txns;
}
-GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other509) {
- txn_high_water_mark = other509.txn_high_water_mark;
- open_txns = other509.open_txns;
+GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other525) {
+ txn_high_water_mark = other525.txn_high_water_mark;
+ open_txns = other525.open_txns;
return *this;
}
void GetOpenTxnsResponse::printTo(std::ostream& out) const {
@@ -11905,19 +12117,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) {
swap(a.__isset, b.__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(const OpenTxnRequest& other526) {
+ num_txns = other526.num_txns;
+ user = other526.user;
+ hostname = other526.hostname;
+ agentInfo = other526.agentInfo;
+ __isset = other526.__isset;
}
-OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other511) {
- num_txns = other511.num_txns;
- user = other511.user;
- hostname = other511.hostname;
- agentInfo = other511.agentInfo;
- __isset = other511.__isset;
+OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other527) {
+ num_txns = other527.num_txns;
+ user = other527.user;
+ hostname = other527.hostname;
+ agentInfo = other527.agentInfo;
+ __isset = other527.__isset;
return *this;
}
void OpenTxnRequest::printTo(std::ostream& out) const {
@@ -11965,14 +12177,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- 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)
+ uint32_t _size528;
+ ::apache::thrift::protocol::TType _etype531;
+ xfer += iprot->readListBegin(_etype531, _size528);
+ this->txn_ids.resize(_size528);
+ uint32_t _i532;
+ for (_i532 = 0; _i532 < _size528; ++_i532)
{
- xfer += iprot->readI64(this->txn_ids[_i516]);
+ xfer += iprot->readI64(this->txn_ids[_i532]);
}
xfer += iprot->readListEnd();
}
@@ -12003,10 +12215,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 _iter517;
- for (_iter517 = this->txn_ids.begin(); _iter517 != this->txn_ids.end(); ++_iter517)
+ std::vector<int64_t> ::const_iterator _iter533;
+ for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533)
{
- xfer += oprot->writeI64((*_iter517));
+ xfer += oprot->writeI64((*_iter533));
}
xfer += oprot->writeListEnd();
}
@@ -12022,11 +12234,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) {
swap(a.txn_ids, b.txn_ids);
}
-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other518) {
- txn_ids = other518.txn_ids;
+OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) {
+ txn_ids = other534.txn_ids;
}
-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other519) {
- txn_ids = other519.txn_ids;
+OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) {
+ txn_ids = other535.txn_ids;
return *this;
}
void OpenTxnsResponse::printTo(std::ostream& out) const {
@@ -12108,11 +12320,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other520) {
- txnid = other520.txnid;
+AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) {
+ txnid = other536.txnid;
}
-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other521) {
- txnid = other521.txnid;
+AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) {
+ txnid = other537.txnid;
return *this;
}
void AbortTxnRequest::printTo(std::ostream& out) const {
@@ -12157,14 +12369,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- uint32_t _size522;
- ::apache::thrift::protocol::TType _etype525;
- xfer += iprot->readListBegin(_etype525, _size522);
- this->txn_ids.resize(_size522);
- uint32_t _i526;
- for (_i526 = 0; _i526 < _size522; ++_i526)
+ uint32_t _size538;
+ ::apache::thrift::protocol::TType _etype541;
+ xfer += iprot->readListBegin(_etype541, _size538);
+ this->txn_ids.resize(_size538);
+ uint32_t _i542;
+ for (_i542 = 0; _i542 < _size538; ++_i542)
{
- xfer += iprot->readI64(this->txn_ids[_i526]);
+ xfer += iprot->readI64(this->txn_ids[_i542]);
}
xfer += iprot->readListEnd();
}
@@ -12195,10 +12407,10 @@ uint32_t AbortTxnsRequest::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 _iter527;
- for (_iter527 = this->txn_ids.begin(); _iter527 != this->txn_ids.end(); ++_iter527)
+ std::vector<int64_t> ::const_iterator _iter543;
+ for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543)
{
- xfer += oprot->writeI64((*_iter527));
+ xfer += oprot->writeI64((*_iter543));
}
xfer += oprot->writeListEnd();
}
@@ -12214,11 +12426,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) {
swap(a.txn_ids, b.txn_ids);
}
-AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other528) {
- txn_ids = other528.txn_ids;
+AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) {
+ txn_ids = other544.txn_ids;
}
-AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other529) {
- txn_ids = other529.txn_ids;
+AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) {
+ txn_ids = other545.txn_ids;
return *this;
}
void AbortTxnsRequest::printTo(std::ostream& out) const {
@@ -12300,11 +12512,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other530) {
- txnid = other530.txnid;
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) {
+ txnid = other546.txnid;
}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other531) {
- txnid = other531.txnid;
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) {
+ txnid = other547.txnid;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -12367,9 +12579,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast532;
- xfer += iprot->readI32(ecast532);
- this->type = (LockType::type)ecast532;
+ int32_t ecast548;
+ xfer += iprot->readI32(ecast548);
+ this->type = (LockType::type)ecast548;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12377,9 +12589,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast533;
- xfer += iprot->readI32(ecast533);
- this->level = (LockLevel::type)ecast533;
+ int32_t ecast549;
+ xfer += iprot->readI32(ecast549);
+ this->level = (LockLevel::type)ecast549;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -12469,21 +12681,21 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-LockComponent::LockComponent(const LockComponent& other534) {
- type = other534.type;
- level = other534.level;
- dbname = other534.dbname;
- tablename = other534.tablename;
- partitionname = other534.partitionname;
- __isset = other534.__isset;
-}
-LockComponent& LockComponent::operator=(const LockComponent& other535) {
- type = other535.type;
- level = other535.level;
- dbname = other535.dbname;
- tablename = other535.tablename;
- partitionname = other535.partitionname;
- __isset = other535.__isset;
+LockComponent::LockComponent(const LockComponent& other550) {
+ type = other550.type;
+ level = other550.level;
+ dbname = other550.dbname;
+ tablename = other550.tablename;
+ partitionname = other550.partitionname;
+ __isset = other550.__isset;
+}
+LockComponent& LockComponent::operator=(const LockComponent& other551) {
+ type = other551.type;
+ level = other551.level;
+ dbname = other551.dbname;
+ tablename = other551.tablename;
+ partitionname = other551.partitionname;
+ __isset = other551.__isset;
return *this;
}
void LockComponent::printTo(std::ostream& out) const {
@@ -12552,14 +12764,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- uint32_t _size536;
- ::apache::thrift::protocol::TType _etype539;
- xfer += iprot->readListBegin(_etype539, _size536);
- this->component.resize(_size536);
- uint32_t _i540;
- for (_i540 = 0; _i540 < _size536; ++_i540)
+ uint32_t _size552;
+ ::apache::thrift::protocol::TType _etype555;
+ xfer += iprot->readListBegin(_etype555, _size552);
+ this->component.resize(_size552);
+ uint32_t _i556;
+ for (_i556 = 0; _i556 < _size552; ++_i556)
{
- xfer += this->component[_i540].read(iprot);
+ xfer += this->component[_i556].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -12626,10 +12838,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 _iter541;
- for (_iter541 = this->component.begin(); _iter541 != this->component.end(); ++_iter541)
+ std::vector<LockComponent> ::const_iterator _iter557;
+ for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557)
{
- xfer += (*_iter541).write(oprot);
+ xfer += (*_iter557).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -12668,21 +12880,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-LockRequest::LockRequest(const LockRequest& other542) {
- component = other542.component;
- txnid = other542.txnid;
- user = other542.user;
- hostname = other542.hostname;
- agentInfo = other542.agentInfo;
- __isset = other542.__isset;
-}
-LockRequest& LockRequest::operator=(const LockRequest& other543) {
- component = other543.component;
- txnid = other543.txnid;
- user = other543.user;
- hostname = other543.hostname;
- agentInfo = other543.agentInfo;
- __isset = other543.__isset;
+LockRequest::LockRequest(const LockRequest& other558) {
+ component = other558.component;
+ txnid = other558.txnid;
+ user = other558.user;
+ hostname = other558.hostname;
+ agentInfo = other558.agentInfo;
+ __isset = other558.__isset;
+}
+LockRequest& LockRequest::operator=(const LockRequest& other559) {
+ component = other559.component;
+ txnid = other559.txnid;
+ user = other559.user;
+ hostname = other559.hostname;
+ agentInfo = other559.agentInfo;
+ __isset = other559.__isset;
return *this;
}
void LockRequest::printTo(std::ostream& out) const {
@@ -12742,9 +12954,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast544;
- xfer += iprot->readI32(ecast544);
- this->state = (LockState::type)ecast544;
+ int32_t ecast560;
+ xfer += iprot->readI32(ecast560);
+ this->state = (LockState::type)ecast560;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -12790,13 +13002,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other545) {
- lockid = other545.lockid;
- state = other545.state;
+LockResponse::LockResponse(const LockResponse& other561) {
+ lockid = other561.lockid;
+ state = other561.state;
}
-LockResponse& LockResponse::operator=(const LockResponse& other546) {
- lockid = other546.lockid;
- state = other546.state;
+LockResponse& LockResponse::operator=(const LockResponse& other562) {
+ lockid = other562.lockid;
+ state = other562.state;
return *this;
}
void LockResponse::printTo(std::ostream& out) const {
@@ -12918,17 +13130,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-CheckLockRequest::CheckLockRequest(const CheckLockRequest& other547) {
- lockid = other547.lockid;
- txnid = other547.txnid;
- elapsed_ms = other547.elapsed_ms;
- __isset = other547.__isset;
-}
-CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other548) {
- lockid = other548.lockid;
- txnid = other548.txnid;
- elapsed_ms = other548.elapsed_ms;
- __isset = other548.__isset;
+CheckLockRequest::CheckLockRequest(const CheckLockRequest& other563) {
+ lockid = other563.lockid;
+ txnid = other563.txnid;
+ elapsed_ms = other563.elapsed_ms;
+ __isset = other563.__isset;
+}
+CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other564) {
+ lockid = other564.lockid;
+ txnid = other564.txnid;
+ elapsed_ms = other564.elapsed_ms;
+ __isset = other564.__isset;
return *this;
}
void CheckLockRequest::printTo(std::ostream& out) const {
@@ -13012,11 +13224,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other549) {
- lockid = other549.lockid;
+UnlockRequest::UnlockRequest(const UnlockRequest& other565) {
+ lockid = other565.lockid;
}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other550) {
- lockid = other550.lockid;
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) {
+ lockid = other566.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -13155,19 +13367,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other551) {
- dbname = other551.dbname;
- tablename = other551.tablename;
- partname = other551.partname;
- isExtended = other551.isExtended;
- __isset = other551.__isset;
+ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other567) {
+ dbname = other567.dbname;
+ tablename = other567.tablename;
+ partname = other567.partname;
+ isExtended = other567.isExtended;
+ __isset = other567.__isset;
}
-ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other552) {
- dbname = other552.dbname;
- tablename = other552.tablename;
- partname = other552.partname;
- isExtended = other552.isExtended;
- __isset = other552.__isset;
+ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other568) {
+ dbname = other568.dbname;
+ tablename = other568.tablename;
+ partname = other568.partname;
+ isExtended = other568.isExtended;
+ __isset = other568.__isset;
return *this;
}
void ShowLocksRequest::printTo(std::ostream& out) const {
@@ -13320,9 +13532,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast553;
- xfer += iprot->readI32(ecast553);
- this->state = (LockState::type)ecast553;
+ int32_t ecast569;
+ xfer += iprot->readI32(ecast569);
+ this->state = (LockState::type)ecast569;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13330,9 +13542,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast554;
- xfer += iprot->readI32(ecast554);
- this->type = (LockType::type)ecast554;
+ int32_t ecast570;
+ xfer += iprot->readI32(ecast570);
+ this->type = (LockType::type)ecast570;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -13548,43 +13760,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other555) {
- lockid = other555.lockid;
- dbname = other555.dbname;
- tablename = other555.tablename;
- partname = other555.partname;
- state = other555.state;
- type = other555.type;
- txnid = other555.txnid;
- lastheartbeat = other555.lastheartbeat;
- acquiredat = other555.acquiredat;
- user = other555.user;
- hostname = other555.hostname;
- heartbeatCount = other555.heartbeatCount;
- agentInfo = other555.agentInfo;
- blockedByExtId = other555.blockedByExtId;
- blockedByIntId = other555.blockedByIntId;
- lockIdInternal = other555.lockIdInternal;
- __isset = other555.__isset;
-}
-ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other556) {
- lockid = other556.lockid;
- dbname = other556.dbname;
- tablename = other556.tablename;
- partname = other556.partname;
- state = other556.state;
- type = other556.type;
- txnid = other556.txnid;
- lastheartbeat = other556.lastheartbeat;
- acquiredat = other556.acquiredat;
- user = other556.user;
- hostname = other556.hostname;
- heartbeatCount = other556.heartbeatCount;
- agentInfo = other556.agentInfo;
- blockedByExtId = other556.blockedByExtId;
- blockedByIntId = other556.blockedByIntId;
- lockIdInternal = other556.lockIdInternal;
- __isset = other556.__isset;
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other571) {
+ lockid = other571.lockid;
+ dbname = other571.dbname;
+ tablename = other571.tablename;
+ partname = other571.partname;
+ state = other571.state;
+ type = other571.type;
+ txnid = other571.txnid;
+ lastheartbeat = other571.lastheartbeat;
+ acquiredat = other571.acquiredat;
+ user = other571.user;
+ hostname = other571.hostname;
+ heartbeatCount = other571.heartbeatCount;
+ agentInfo = other571.agentInfo;
+ blockedByExtId = other571.blockedByExtId;
+ blockedByIntId = other571.blockedByIntId;
+ lockIdInternal = other571.lockIdInternal;
+ __isset = other571.__isset;
+}
+ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other572) {
+ lockid = other572.lockid;
+ dbname = other572.dbname;
+ tablename = other572.tablename;
+ partname = other572.partname;
+ state = other572.state;
+ type = other572.type;
+ txnid = other572.txnid;
+ lastheartbeat = other572.lastheartbeat;
+ acquiredat = other572.acquiredat;
+ user = other572.user;
+ hostname = other572.hostname;
+ heartbeatCount = other572.heartbeatCount;
+ agentInfo = other572.agentInfo;
+ blockedByExtId = other572.blockedByExtId;
+ blockedByIntId = other572.blockedByIntId;
+ lockIdInternal = other572.lockIdInternal;
+ __isset = other572.__isset;
return *this;
}
void ShowLocksResponseElement::printTo(std::ostream& out) const {
@@ -13643,14 +13855,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- uint32_t _size557;
- ::apache::thrift::protocol::TType _etype560;
- xfer += iprot->readListBegin(_etype560, _size557);
- this->locks.resize(_size557);
- uint32_t _i561;
- for (_i561 = 0; _i561 < _size557; ++_i561)
+ uint32_t _size573;
+ ::apache::thrift::protocol::TType _etype576;
+ xfer += iprot->readListBegin(_etype576, _size573);
+ this->locks.resize(_size573);
+ uint32_t _i577;
+ for (_i577 = 0; _i577 < _size573; ++_i577)
{
- xfer += this->locks[_i561].read(iprot);
+ xfer += this->locks[_i577].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -13679,10 +13891,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 _iter562;
- for (_iter562 = this->locks.begin(); _iter562 != this->locks.end(); ++_iter562)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter578;
+ for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578)
{
- xfer += (*_iter562).write(oprot);
+ xfer += (*_iter578).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13699,13 +13911,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other563) {
- locks = other563.locks;
- __isset = other563.__isset;
+ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) {
+ locks = other579.locks;
+ __isset = other579.__isset;
}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other564) {
- locks = other564.locks;
- __isset = other564.__isset;
+ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other580) {
+ locks = other580.locks;
+ __isset = other580.__isset;
return *this;
}
void ShowLocksResponse::printTo(std::ostream& out) const {
@@ -13806,15 +14018,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other565) {
- lockid = other565.lockid;
- txnid = other565.txnid;
- __isset = other565.__isset;
+HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) {
+ lockid = other581.lockid;
+ txnid = other581.txnid;
+ __isset = other581.__isset;
}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other566) {
- lockid = other566.lockid;
- txnid = other566.txnid;
- __isset = other566.__isset;
+HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other582) {
+ lockid = other582.lockid;
+ txnid = other582.txnid;
+ __isset = other582.__isset;
return *this;
}
void HeartbeatRequest::printTo(std::ostream& out) const {
@@ -13917,13 +14129,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other567) {
- min = other567.min;
- max = other567.max;
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) {
+ min = other583.min;
+ max = other583.max;
}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other568) {
- min = other568.min;
- max = other568.max;
+HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other584) {
+ min = other584.min;
+ max = other584.max;
return *this;
}
void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const {
@@ -13974,15 +14186,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size569;
- ::apache::thrift::protocol::TType _etype572;
- xfer += iprot->readSetBegin(_etype572, _size569);
- uint32_t _i573;
- for (_i573 = 0; _i573 < _size569; ++_i573)
+ uint32_t _size585;
+ ::apache::thrift::protocol::TType _etype588;
+ xfer += iprot->readSetBegin(_etype588, _size585);
+ uint32_t _i589;
+ for (_i589 = 0; _i589 < _size585; ++_i589)
{
- int64_t _elem574;
- xfer += iprot->readI64(_elem574);
- this->aborted.insert(_elem574);
+ int64_t _elem590;
+ xfer += iprot->readI64(_elem590);
+ this->aborted.insert(_elem590);
}
xfer += iprot->readSetEnd();
}
@@ -13995,15 +14207,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size575;
- ::apache::thrift::protocol::TType _etype578;
- xfer += iprot->readSetBegin(_etype578, _size575);
- uint32_t _i579;
- for (_i579 = 0; _i579 < _size575; ++_i579)
+ uint32_t _size591;
+ ::apache::thrift::protocol::TType _etype594;
+ xfer += iprot->readSetBegin(_etype594, _size591);
+ uint32_t _i595;
+ for (_i595 = 0; _i595 < _size591; ++_i595)
{
- int64_t _elem580;
- xfer += iprot->readI64(_elem580);
- this->nosuch.insert(_elem580);
+ int64_t _elem596;
+ xfer += iprot->readI64(_elem596);
+ this->nosuch.insert(_elem596);
}
xfer += iprot->readSetEnd();
}
@@ -14036,10 +14248,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 _iter581;
- for (_iter581 = this->aborted.begin(); _iter581 != this->aborted.end(); ++_iter581)
+ std::set<int64_t> ::const_iterator _iter597;
+ for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597)
{
- xfer += oprot->writeI64((*_iter581));
+ xfer += oprot->writeI64((*_iter597));
}
xfer += oprot->writeSetEnd();
}
@@ -14048,10 +14260,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 _iter582;
- for (_iter582 = this->nosuch.begin(); _iter582 != this->nosuch.end(); ++_iter582)
+ std::set<int64_t> ::const_iterator _iter598;
+ for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598)
{
- xfer += oprot->writeI64((*_iter582));
+ xfer += oprot->writeI64((*_iter598));
}
xfer += oprot->writeSetEnd();
}
@@ -14068,13 +14280,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other583) {
- aborted = other583.aborted;
- nosuch = other583.nosuch;
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) {
+ aborted = other599.aborted;
+ nosuch = other599.nosuch;
}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other584) {
- aborted = other584.aborted;
- nosuch = other584.nosuch;
+HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other600) {
+ aborted = other600.aborted;
+ nosuch = other600.nosuch;
return *this;
}
void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const {
@@ -14162,9 +14374,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast585;
- xfer += iprot->readI32(ecast585);
- this->type = (CompactionType::type)ecast585;
+ int32_t ecast601;
+ xfer += iprot->readI32(ecast601);
+ this->type = (CompactionType::type)ecast601;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14238,21 +14450,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-CompactionRequest::CompactionRequest(const CompactionRequest& other586) {
- dbname = other586.dbname;
- tablename = other586.tablename;
- partitionname = other586.partitionname;
- type = other586.type;
- runas = other586.runas;
- __isset = other586.__isset;
-}
-CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other587) {
- dbname = other587.dbname;
- tablename = other587.tablename;
- partitionname = other587.partitionname;
- type = other587.type;
- runas = other587.runas;
- __isset = other587.__isset;
+CompactionRequest::CompactionRequest(const CompactionRequest& other602) {
+ dbname = other602.dbname;
+ tablename = other602.tablename;
+ partitionname = other602.partitionname;
+ type = other602.type;
+ runas = other602.runas;
+ __isset = other602.__isset;
+}
+CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other603) {
+ dbname = other603.dbname;
+ tablename = other603.tablename;
+ partitionname = other603.partitionname;
+ type = other603.type;
+ runas = other603.runas;
+ __isset = other603.__isset;
return *this;
}
void CompactionRequest::printTo(std::ostream& out) const {
@@ -14315,11 +14527,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other588) {
- (void) other588;
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other604) {
+ (void) other604;
}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other589) {
- (void) other589;
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other605) {
+ (void) other605;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -14440,9 +14652,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast590;
- xfer += iprot->readI32(ecast590);
- this->type = (CompactionType::type)ecast590;
+ int32_t ecast606;
+ xfer += iprot->readI32(ecast606);
+ this->type = (CompactionType::type)ecast606;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14615,35 +14827,35 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other591) {
- dbname = other591.dbname;
- tablename = other591.tablename;
- partitionname = other591.partitionname;
- type = other591.type;
- state = other591.state;
- workerid = other591.workerid;
- start = other591.start;
- runAs = other591.runAs;
- hightestTxnId = other591.hightestTxnId;
- metaInfo = other591.metaInfo;
- endTime = other591.endTime;
- hadoopJobId = other591.hadoopJobId;
- __isset = other591.__isset;
-}
-ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other592) {
- dbname = other592.dbname;
- tablename = other592.tablename;
- partitionname = other592.partitionname;
- type = other592.type;
- state = other592.state;
- workerid = other592.workerid;
- start = other592.start;
- runAs = other592.runAs;
- hightestTxnId = other592.hightestTxnId;
- metaInfo = other592.metaInfo;
- endTime = other592.endTime;
- hadoopJobId = other592.hadoopJobId;
- __isset = other592.__isset;
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other607) {
+ dbname = other607.dbname;
+ tablename = other607.tablename;
+ partitionname = other607.partitionname;
+ type = other607.type;
+ state = other607.state;
+ workerid = other607.workerid;
+ start = other607.start;
+ runAs = other607.runAs;
+ hightestTxnId = other607.hightestTxnId;
+ metaInfo = other607.metaInfo;
+ endTime = other607.endTime;
+ hadoopJobId = other607.hadoopJobId;
+ __isset = other607.__isset;
+}
+ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other608) {
+ dbname = other608.dbname;
+ tablename = other608.tablename;
+ partitionname = other608.partitionname;
+ type = other608.type;
+ state = other608.state;
+ workerid = other608.workerid;
+ start = other608.start;
+ runAs = other608.runAs;
+ hightestTxnId = other608.hightestTxnId;
+ metaInfo = other608.metaInfo;
+ endTime = other608.endTime;
+ hadoopJobId = other608.hadoopJobId;
+ __isset = other608.__isset;
return *this;
}
void ShowCompactResponseElement::printTo(std::ostream& out) const {
@@ -14699,14 +14911,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- uint32_t _size593;
- ::apache::thrift::protocol::TType _etype596;
- xfer += iprot->readListBegin(_etype596, _size593);
- this->compacts.resize(_size593);
- uint32_t _i597;
- for (_i597 = 0; _i597 < _size593; ++_i597)
+ uint32_t _size609;
+ ::apache::thrift::protocol::TType _etype612;
+ xfer += iprot->readListBegin(_etype612, _size609);
+ this->compacts.resize(_size609);
+ uint32_t _i613;
+ for (_i613 = 0; _i613 < _size609; ++_i613)
{
- xfer += this->compacts[_i597].read(iprot);
+ xfer += this->compacts[_i613].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -14737,10 +14949,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot
xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += opro
<TRUNCATED>