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>