http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 5c09fdd..b3c9798 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -12290,6 +12290,503 @@ void DropPartitionsRequest::printTo(std::ostream& out) const { } +PartitionValuesRequest::~PartitionValuesRequest() throw() { +} + + +void PartitionValuesRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void PartitionValuesRequest::__set_tblName(const std::string& val) { + this->tblName = val; +} + +void PartitionValuesRequest::__set_partitionKeys(const std::vector<FieldSchema> & val) { + this->partitionKeys = val; +} + +void PartitionValuesRequest::__set_applyDistinct(const bool val) { + this->applyDistinct = val; +__isset.applyDistinct = true; +} + +void PartitionValuesRequest::__set_filter(const std::string& val) { + this->filter = val; +__isset.filter = true; +} + +void PartitionValuesRequest::__set_partitionOrder(const std::vector<FieldSchema> & val) { + this->partitionOrder = val; +__isset.partitionOrder = true; +} + +void PartitionValuesRequest::__set_ascending(const bool val) { + this->ascending = val; +__isset.ascending = true; +} + +void PartitionValuesRequest::__set_maxParts(const int64_t val) { + this->maxParts = val; +__isset.maxParts = true; +} + +uint32_t PartitionValuesRequest::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_tblName = false; + bool isset_partitionKeys = 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->tblName); + isset_tblName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionKeys.clear(); + uint32_t _size533; + ::apache::thrift::protocol::TType _etype536; + xfer += iprot->readListBegin(_etype536, _size533); + this->partitionKeys.resize(_size533); + uint32_t _i537; + for (_i537 = 0; _i537 < _size533; ++_i537) + { + xfer += this->partitionKeys[_i537].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitionKeys = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->applyDistinct); + this->__isset.applyDistinct = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->filter); + this->__isset.filter = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partitionOrder.clear(); + uint32_t _size538; + ::apache::thrift::protocol::TType _etype541; + xfer += iprot->readListBegin(_etype541, _size538); + this->partitionOrder.resize(_size538); + uint32_t _i542; + for (_i542 = 0; _i542 < _size538; ++_i542) + { + xfer += this->partitionOrder[_i542].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.partitionOrder = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 7: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->ascending); + this->__isset.ascending = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 8: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->maxParts); + this->__isset.maxParts = 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_tblName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partitionKeys) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesRequest"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tblName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partitionKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionKeys.size())); + std::vector<FieldSchema> ::const_iterator _iter543; + for (_iter543 = this->partitionKeys.begin(); _iter543 != this->partitionKeys.end(); ++_iter543) + { + xfer += (*_iter543).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.applyDistinct) { + xfer += oprot->writeFieldBegin("applyDistinct", ::apache::thrift::protocol::T_BOOL, 4); + xfer += oprot->writeBool(this->applyDistinct); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.filter) { + xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->filter); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.partitionOrder) { + xfer += oprot->writeFieldBegin("partitionOrder", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionOrder.size())); + std::vector<FieldSchema> ::const_iterator _iter544; + for (_iter544 = this->partitionOrder.begin(); _iter544 != this->partitionOrder.end(); ++_iter544) + { + xfer += (*_iter544).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.ascending) { + xfer += oprot->writeFieldBegin("ascending", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeBool(this->ascending); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.maxParts) { + xfer += oprot->writeFieldBegin("maxParts", ::apache::thrift::protocol::T_I64, 8); + xfer += oprot->writeI64(this->maxParts); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesRequest &a, PartitionValuesRequest &b) { + using ::std::swap; + swap(a.dbName, b.dbName); + swap(a.tblName, b.tblName); + swap(a.partitionKeys, b.partitionKeys); + swap(a.applyDistinct, b.applyDistinct); + swap(a.filter, b.filter); + swap(a.partitionOrder, b.partitionOrder); + swap(a.ascending, b.ascending); + swap(a.maxParts, b.maxParts); + swap(a.__isset, b.__isset); +} + +PartitionValuesRequest::PartitionValuesRequest(const PartitionValuesRequest& other545) { + dbName = other545.dbName; + tblName = other545.tblName; + partitionKeys = other545.partitionKeys; + applyDistinct = other545.applyDistinct; + filter = other545.filter; + partitionOrder = other545.partitionOrder; + ascending = other545.ascending; + maxParts = other545.maxParts; + __isset = other545.__isset; +} +PartitionValuesRequest& PartitionValuesRequest::operator=(const PartitionValuesRequest& other546) { + dbName = other546.dbName; + tblName = other546.tblName; + partitionKeys = other546.partitionKeys; + applyDistinct = other546.applyDistinct; + filter = other546.filter; + partitionOrder = other546.partitionOrder; + ascending = other546.ascending; + maxParts = other546.maxParts; + __isset = other546.__isset; + return *this; +} +void PartitionValuesRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesRequest("; + out << "dbName=" << to_string(dbName); + out << ", " << "tblName=" << to_string(tblName); + out << ", " << "partitionKeys=" << to_string(partitionKeys); + out << ", " << "applyDistinct="; (__isset.applyDistinct ? (out << to_string(applyDistinct)) : (out << "<null>")); + out << ", " << "filter="; (__isset.filter ? (out << to_string(filter)) : (out << "<null>")); + out << ", " << "partitionOrder="; (__isset.partitionOrder ? (out << to_string(partitionOrder)) : (out << "<null>")); + out << ", " << "ascending="; (__isset.ascending ? (out << to_string(ascending)) : (out << "<null>")); + out << ", " << "maxParts="; (__isset.maxParts ? (out << to_string(maxParts)) : (out << "<null>")); + out << ")"; +} + + +PartitionValuesRow::~PartitionValuesRow() throw() { +} + + +void PartitionValuesRow::__set_row(const std::vector<std::string> & val) { + this->row = val; +} + +uint32_t PartitionValuesRow::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_row = 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->row.clear(); + uint32_t _size547; + ::apache::thrift::protocol::TType _etype550; + xfer += iprot->readListBegin(_etype550, _size547); + this->row.resize(_size547); + uint32_t _i551; + for (_i551 = 0; _i551 < _size547; ++_i551) + { + xfer += iprot->readString(this->row[_i551]); + } + xfer += iprot->readListEnd(); + } + isset_row = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_row) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesRow::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesRow"); + + xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->row.size())); + std::vector<std::string> ::const_iterator _iter552; + for (_iter552 = this->row.begin(); _iter552 != this->row.end(); ++_iter552) + { + xfer += oprot->writeString((*_iter552)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesRow &a, PartitionValuesRow &b) { + using ::std::swap; + swap(a.row, b.row); +} + +PartitionValuesRow::PartitionValuesRow(const PartitionValuesRow& other553) { + row = other553.row; +} +PartitionValuesRow& PartitionValuesRow::operator=(const PartitionValuesRow& other554) { + row = other554.row; + return *this; +} +void PartitionValuesRow::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesRow("; + out << "row=" << to_string(row); + out << ")"; +} + + +PartitionValuesResponse::~PartitionValuesResponse() throw() { +} + + +void PartitionValuesResponse::__set_partitionValues(const std::vector<PartitionValuesRow> & val) { + this->partitionValues = val; +} + +uint32_t PartitionValuesResponse::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_partitionValues = 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->partitionValues.clear(); + uint32_t _size555; + ::apache::thrift::protocol::TType _etype558; + xfer += iprot->readListBegin(_etype558, _size555); + this->partitionValues.resize(_size555); + uint32_t _i559; + for (_i559 = 0; _i559 < _size555; ++_i559) + { + xfer += this->partitionValues[_i559].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_partitionValues = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_partitionValues) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t PartitionValuesResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("PartitionValuesResponse"); + + xfer += oprot->writeFieldBegin("partitionValues", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitionValues.size())); + std::vector<PartitionValuesRow> ::const_iterator _iter560; + for (_iter560 = this->partitionValues.begin(); _iter560 != this->partitionValues.end(); ++_iter560) + { + xfer += (*_iter560).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(PartitionValuesResponse &a, PartitionValuesResponse &b) { + using ::std::swap; + swap(a.partitionValues, b.partitionValues); +} + +PartitionValuesResponse::PartitionValuesResponse(const PartitionValuesResponse& other561) { + partitionValues = other561.partitionValues; +} +PartitionValuesResponse& PartitionValuesResponse::operator=(const PartitionValuesResponse& other562) { + partitionValues = other562.partitionValues; + return *this; +} +void PartitionValuesResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "PartitionValuesResponse("; + out << "partitionValues=" << to_string(partitionValues); + out << ")"; +} + + ResourceUri::~ResourceUri() throw() { } @@ -12325,9 +12822,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast533; - xfer += iprot->readI32(ecast533); - this->resourceType = (ResourceType::type)ecast533; + int32_t ecast563; + xfer += iprot->readI32(ecast563); + this->resourceType = (ResourceType::type)ecast563; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -12378,15 +12875,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other534) { - resourceType = other534.resourceType; - uri = other534.uri; - __isset = other534.__isset; +ResourceUri::ResourceUri(const ResourceUri& other564) { + resourceType = other564.resourceType; + uri = other564.uri; + __isset = other564.__isset; } -ResourceUri& ResourceUri::operator=(const ResourceUri& other535) { - resourceType = other535.resourceType; - uri = other535.uri; - __isset = other535.__isset; +ResourceUri& ResourceUri::operator=(const ResourceUri& other565) { + resourceType = other565.resourceType; + uri = other565.uri; + __isset = other565.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -12489,9 +12986,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast536; - xfer += iprot->readI32(ecast536); - this->ownerType = (PrincipalType::type)ecast536; + int32_t ecast566; + xfer += iprot->readI32(ecast566); + this->ownerType = (PrincipalType::type)ecast566; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -12507,9 +13004,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast537; - xfer += iprot->readI32(ecast537); - this->functionType = (FunctionType::type)ecast537; + int32_t ecast567; + xfer += iprot->readI32(ecast567); + this->functionType = (FunctionType::type)ecast567; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -12519,14 +13016,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size538; - ::apache::thrift::protocol::TType _etype541; - xfer += iprot->readListBegin(_etype541, _size538); - this->resourceUris.resize(_size538); - uint32_t _i542; - for (_i542 = 0; _i542 < _size538; ++_i542) + uint32_t _size568; + ::apache::thrift::protocol::TType _etype571; + xfer += iprot->readListBegin(_etype571, _size568); + this->resourceUris.resize(_size568); + uint32_t _i572; + for (_i572 = 0; _i572 < _size568; ++_i572) { - xfer += this->resourceUris[_i542].read(iprot); + xfer += this->resourceUris[_i572].read(iprot); } xfer += iprot->readListEnd(); } @@ -12583,10 +13080,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 _iter543; - for (_iter543 = this->resourceUris.begin(); _iter543 != this->resourceUris.end(); ++_iter543) + std::vector<ResourceUri> ::const_iterator _iter573; + for (_iter573 = this->resourceUris.begin(); _iter573 != this->resourceUris.end(); ++_iter573) { - xfer += (*_iter543).write(oprot); + xfer += (*_iter573).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12610,27 +13107,27 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other544) { - functionName = other544.functionName; - dbName = other544.dbName; - className = other544.className; - ownerName = other544.ownerName; - ownerType = other544.ownerType; - createTime = other544.createTime; - functionType = other544.functionType; - resourceUris = other544.resourceUris; - __isset = other544.__isset; -} -Function& Function::operator=(const Function& other545) { - functionName = other545.functionName; - dbName = other545.dbName; - className = other545.className; - ownerName = other545.ownerName; - ownerType = other545.ownerType; - createTime = other545.createTime; - functionType = other545.functionType; - resourceUris = other545.resourceUris; - __isset = other545.__isset; +Function::Function(const Function& other574) { + functionName = other574.functionName; + dbName = other574.dbName; + className = other574.className; + ownerName = other574.ownerName; + ownerType = other574.ownerType; + createTime = other574.createTime; + functionType = other574.functionType; + resourceUris = other574.resourceUris; + __isset = other574.__isset; +} +Function& Function::operator=(const Function& other575) { + functionName = other575.functionName; + dbName = other575.dbName; + className = other575.className; + ownerName = other575.ownerName; + ownerType = other575.ownerType; + createTime = other575.createTime; + functionType = other575.functionType; + resourceUris = other575.resourceUris; + __isset = other575.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -12728,9 +13225,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast546; - xfer += iprot->readI32(ecast546); - this->state = (TxnState::type)ecast546; + int32_t ecast576; + xfer += iprot->readI32(ecast576); + this->state = (TxnState::type)ecast576; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -12877,29 +13374,29 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other547) { - id = other547.id; - state = other547.state; - user = other547.user; - hostname = other547.hostname; - agentInfo = other547.agentInfo; - heartbeatCount = other547.heartbeatCount; - metaInfo = other547.metaInfo; - startedTime = other547.startedTime; - lastHeartbeatTime = other547.lastHeartbeatTime; - __isset = other547.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other548) { - id = other548.id; - state = other548.state; - user = other548.user; - hostname = other548.hostname; - agentInfo = other548.agentInfo; - heartbeatCount = other548.heartbeatCount; - metaInfo = other548.metaInfo; - startedTime = other548.startedTime; - lastHeartbeatTime = other548.lastHeartbeatTime; - __isset = other548.__isset; +TxnInfo::TxnInfo(const TxnInfo& other577) { + id = other577.id; + state = other577.state; + user = other577.user; + hostname = other577.hostname; + agentInfo = other577.agentInfo; + heartbeatCount = other577.heartbeatCount; + metaInfo = other577.metaInfo; + startedTime = other577.startedTime; + lastHeartbeatTime = other577.lastHeartbeatTime; + __isset = other577.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other578) { + id = other578.id; + state = other578.state; + user = other578.user; + hostname = other578.hostname; + agentInfo = other578.agentInfo; + heartbeatCount = other578.heartbeatCount; + metaInfo = other578.metaInfo; + startedTime = other578.startedTime; + lastHeartbeatTime = other578.lastHeartbeatTime; + __isset = other578.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -12965,14 +13462,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size549; - ::apache::thrift::protocol::TType _etype552; - xfer += iprot->readListBegin(_etype552, _size549); - this->open_txns.resize(_size549); - uint32_t _i553; - for (_i553 = 0; _i553 < _size549; ++_i553) + uint32_t _size579; + ::apache::thrift::protocol::TType _etype582; + xfer += iprot->readListBegin(_etype582, _size579); + this->open_txns.resize(_size579); + uint32_t _i583; + for (_i583 = 0; _i583 < _size579; ++_i583) { - xfer += this->open_txns[_i553].read(iprot); + xfer += this->open_txns[_i583].read(iprot); } xfer += iprot->readListEnd(); } @@ -13009,10 +13506,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 _iter554; - for (_iter554 = this->open_txns.begin(); _iter554 != this->open_txns.end(); ++_iter554) + std::vector<TxnInfo> ::const_iterator _iter584; + for (_iter584 = this->open_txns.begin(); _iter584 != this->open_txns.end(); ++_iter584) { - xfer += (*_iter554).write(oprot); + xfer += (*_iter584).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13029,13 +13526,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other555) { - txn_high_water_mark = other555.txn_high_water_mark; - open_txns = other555.open_txns; +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other585) { + txn_high_water_mark = other585.txn_high_water_mark; + open_txns = other585.open_txns; } -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other556) { - txn_high_water_mark = other556.txn_high_water_mark; - open_txns = other556.open_txns; +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other586) { + txn_high_water_mark = other586.txn_high_water_mark; + open_txns = other586.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -13104,14 +13601,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size557; - ::apache::thrift::protocol::TType _etype560; - xfer += iprot->readListBegin(_etype560, _size557); - this->open_txns.resize(_size557); - uint32_t _i561; - for (_i561 = 0; _i561 < _size557; ++_i561) + uint32_t _size587; + ::apache::thrift::protocol::TType _etype590; + xfer += iprot->readListBegin(_etype590, _size587); + this->open_txns.resize(_size587); + uint32_t _i591; + for (_i591 = 0; _i591 < _size587; ++_i591) { - xfer += iprot->readI64(this->open_txns[_i561]); + xfer += iprot->readI64(this->open_txns[_i591]); } xfer += iprot->readListEnd(); } @@ -13166,10 +13663,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size())); - std::vector<int64_t> ::const_iterator _iter562; - for (_iter562 = this->open_txns.begin(); _iter562 != this->open_txns.end(); ++_iter562) + std::vector<int64_t> ::const_iterator _iter592; + for (_iter592 = this->open_txns.begin(); _iter592 != this->open_txns.end(); ++_iter592) { - xfer += oprot->writeI64((*_iter562)); + xfer += oprot->writeI64((*_iter592)); } xfer += oprot->writeListEnd(); } @@ -13198,19 +13695,19 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other563) { - txn_high_water_mark = other563.txn_high_water_mark; - open_txns = other563.open_txns; - min_open_txn = other563.min_open_txn; - abortedBits = other563.abortedBits; - __isset = other563.__isset; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other593) { + txn_high_water_mark = other593.txn_high_water_mark; + open_txns = other593.open_txns; + min_open_txn = other593.min_open_txn; + abortedBits = other593.abortedBits; + __isset = other593.__isset; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other564) { - txn_high_water_mark = other564.txn_high_water_mark; - open_txns = other564.open_txns; - min_open_txn = other564.min_open_txn; - abortedBits = other564.abortedBits; - __isset = other564.__isset; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other594) { + txn_high_water_mark = other594.txn_high_water_mark; + open_txns = other594.open_txns; + min_open_txn = other594.min_open_txn; + abortedBits = other594.abortedBits; + __isset = other594.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -13355,19 +13852,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other565) { - num_txns = other565.num_txns; - user = other565.user; - hostname = other565.hostname; - agentInfo = other565.agentInfo; - __isset = other565.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other595) { + num_txns = other595.num_txns; + user = other595.user; + hostname = other595.hostname; + agentInfo = other595.agentInfo; + __isset = other595.__isset; } -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other566) { - num_txns = other566.num_txns; - user = other566.user; - hostname = other566.hostname; - agentInfo = other566.agentInfo; - __isset = other566.__isset; +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other596) { + num_txns = other596.num_txns; + user = other596.user; + hostname = other596.hostname; + agentInfo = other596.agentInfo; + __isset = other596.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -13415,14 +13912,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size567; - ::apache::thrift::protocol::TType _etype570; - xfer += iprot->readListBegin(_etype570, _size567); - this->txn_ids.resize(_size567); - uint32_t _i571; - for (_i571 = 0; _i571 < _size567; ++_i571) + uint32_t _size597; + ::apache::thrift::protocol::TType _etype600; + xfer += iprot->readListBegin(_etype600, _size597); + this->txn_ids.resize(_size597); + uint32_t _i601; + for (_i601 = 0; _i601 < _size597; ++_i601) { - xfer += iprot->readI64(this->txn_ids[_i571]); + xfer += iprot->readI64(this->txn_ids[_i601]); } xfer += iprot->readListEnd(); } @@ -13453,10 +13950,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 _iter572; - for (_iter572 = this->txn_ids.begin(); _iter572 != this->txn_ids.end(); ++_iter572) + std::vector<int64_t> ::const_iterator _iter602; + for (_iter602 = this->txn_ids.begin(); _iter602 != this->txn_ids.end(); ++_iter602) { - xfer += oprot->writeI64((*_iter572)); + xfer += oprot->writeI64((*_iter602)); } xfer += oprot->writeListEnd(); } @@ -13472,11 +13969,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other573) { - txn_ids = other573.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other603) { + txn_ids = other603.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other574) { - txn_ids = other574.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other604) { + txn_ids = other604.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -13558,11 +14055,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other575) { - txnid = other575.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other605) { + txnid = other605.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other576) { - txnid = other576.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other606) { + txnid = other606.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -13607,14 +14104,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size577; - ::apache::thrift::protocol::TType _etype580; - xfer += iprot->readListBegin(_etype580, _size577); - this->txn_ids.resize(_size577); - uint32_t _i581; - for (_i581 = 0; _i581 < _size577; ++_i581) + uint32_t _size607; + ::apache::thrift::protocol::TType _etype610; + xfer += iprot->readListBegin(_etype610, _size607); + this->txn_ids.resize(_size607); + uint32_t _i611; + for (_i611 = 0; _i611 < _size607; ++_i611) { - xfer += iprot->readI64(this->txn_ids[_i581]); + xfer += iprot->readI64(this->txn_ids[_i611]); } xfer += iprot->readListEnd(); } @@ -13645,10 +14142,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 _iter582; - for (_iter582 = this->txn_ids.begin(); _iter582 != this->txn_ids.end(); ++_iter582) + std::vector<int64_t> ::const_iterator _iter612; + for (_iter612 = this->txn_ids.begin(); _iter612 != this->txn_ids.end(); ++_iter612) { - xfer += oprot->writeI64((*_iter582)); + xfer += oprot->writeI64((*_iter612)); } xfer += oprot->writeListEnd(); } @@ -13664,11 +14161,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other583) { - txn_ids = other583.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other613) { + txn_ids = other613.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other584) { - txn_ids = other584.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other614) { + txn_ids = other614.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -13750,11 +14247,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other585) { - txnid = other585.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other615) { + txnid = other615.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other586) { - txnid = other586.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other616) { + txnid = other616.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -13832,9 +14329,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast587; - xfer += iprot->readI32(ecast587); - this->type = (LockType::type)ecast587; + int32_t ecast617; + xfer += iprot->readI32(ecast617); + this->type = (LockType::type)ecast617; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13842,9 +14339,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast588; - xfer += iprot->readI32(ecast588); - this->level = (LockLevel::type)ecast588; + int32_t ecast618; + xfer += iprot->readI32(ecast618); + this->level = (LockLevel::type)ecast618; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -13876,9 +14373,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast589; - xfer += iprot->readI32(ecast589); - this->operationType = (DataOperationType::type)ecast589; + int32_t ecast619; + xfer += iprot->readI32(ecast619); + this->operationType = (DataOperationType::type)ecast619; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -13978,27 +14475,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other590) { - type = other590.type; - level = other590.level; - dbname = other590.dbname; - tablename = other590.tablename; - partitionname = other590.partitionname; - operationType = other590.operationType; - isAcid = other590.isAcid; - isDynamicPartitionWrite = other590.isDynamicPartitionWrite; - __isset = other590.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other591) { - type = other591.type; - level = other591.level; - dbname = other591.dbname; - tablename = other591.tablename; - partitionname = other591.partitionname; - operationType = other591.operationType; - isAcid = other591.isAcid; - isDynamicPartitionWrite = other591.isDynamicPartitionWrite; - __isset = other591.__isset; +LockComponent::LockComponent(const LockComponent& other620) { + type = other620.type; + level = other620.level; + dbname = other620.dbname; + tablename = other620.tablename; + partitionname = other620.partitionname; + operationType = other620.operationType; + isAcid = other620.isAcid; + isDynamicPartitionWrite = other620.isDynamicPartitionWrite; + __isset = other620.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other621) { + type = other621.type; + level = other621.level; + dbname = other621.dbname; + tablename = other621.tablename; + partitionname = other621.partitionname; + operationType = other621.operationType; + isAcid = other621.isAcid; + isDynamicPartitionWrite = other621.isDynamicPartitionWrite; + __isset = other621.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -14070,14 +14567,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readListBegin(_etype595, _size592); - this->component.resize(_size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + uint32_t _size622; + ::apache::thrift::protocol::TType _etype625; + xfer += iprot->readListBegin(_etype625, _size622); + this->component.resize(_size622); + uint32_t _i626; + for (_i626 = 0; _i626 < _size622; ++_i626) { - xfer += this->component[_i596].read(iprot); + xfer += this->component[_i626].read(iprot); } xfer += iprot->readListEnd(); } @@ -14144,10 +14641,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 _iter597; - for (_iter597 = this->component.begin(); _iter597 != this->component.end(); ++_iter597) + std::vector<LockComponent> ::const_iterator _iter627; + for (_iter627 = this->component.begin(); _iter627 != this->component.end(); ++_iter627) { - xfer += (*_iter597).write(oprot); + xfer += (*_iter627).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14186,21 +14683,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other598) { - component = other598.component; - txnid = other598.txnid; - user = other598.user; - hostname = other598.hostname; - agentInfo = other598.agentInfo; - __isset = other598.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other599) { - component = other599.component; - txnid = other599.txnid; - user = other599.user; - hostname = other599.hostname; - agentInfo = other599.agentInfo; - __isset = other599.__isset; +LockRequest::LockRequest(const LockRequest& other628) { + component = other628.component; + txnid = other628.txnid; + user = other628.user; + hostname = other628.hostname; + agentInfo = other628.agentInfo; + __isset = other628.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other629) { + component = other629.component; + txnid = other629.txnid; + user = other629.user; + hostname = other629.hostname; + agentInfo = other629.agentInfo; + __isset = other629.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -14260,9 +14757,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast600; - xfer += iprot->readI32(ecast600); - this->state = (LockState::type)ecast600; + int32_t ecast630; + xfer += iprot->readI32(ecast630); + this->state = (LockState::type)ecast630; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -14308,13 +14805,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other601) { - lockid = other601.lockid; - state = other601.state; +LockResponse::LockResponse(const LockResponse& other631) { + lockid = other631.lockid; + state = other631.state; } -LockResponse& LockResponse::operator=(const LockResponse& other602) { - lockid = other602.lockid; - state = other602.state; +LockResponse& LockResponse::operator=(const LockResponse& other632) { + lockid = other632.lockid; + state = other632.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -14436,17 +14933,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other603) { - lockid = other603.lockid; - txnid = other603.txnid; - elapsed_ms = other603.elapsed_ms; - __isset = other603.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other633) { + lockid = other633.lockid; + txnid = other633.txnid; + elapsed_ms = other633.elapsed_ms; + __isset = other633.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other604) { - lockid = other604.lockid; - txnid = other604.txnid; - elapsed_ms = other604.elapsed_ms; - __isset = other604.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other634) { + lockid = other634.lockid; + txnid = other634.txnid; + elapsed_ms = other634.elapsed_ms; + __isset = other634.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -14530,11 +15027,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other605) { - lockid = other605.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other635) { + lockid = other635.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other606) { - lockid = other606.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other636) { + lockid = other636.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -14673,19 +15170,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other607) { - dbname = other607.dbname; - tablename = other607.tablename; - partname = other607.partname; - isExtended = other607.isExtended; - __isset = other607.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other637) { + dbname = other637.dbname; + tablename = other637.tablename; + partname = other637.partname; + isExtended = other637.isExtended; + __isset = other637.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other608) { - dbname = other608.dbname; - tablename = other608.tablename; - partname = other608.partname; - isExtended = other608.isExtended; - __isset = other608.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other638) { + dbname = other638.dbname; + tablename = other638.tablename; + partname = other638.partname; + isExtended = other638.isExtended; + __isset = other638.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -14838,9 +15335,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast609; - xfer += iprot->readI32(ecast609); - this->state = (LockState::type)ecast609; + int32_t ecast639; + xfer += iprot->readI32(ecast639); + this->state = (LockState::type)ecast639; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -14848,9 +15345,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast610; - xfer += iprot->readI32(ecast610); - this->type = (LockType::type)ecast610; + int32_t ecast640; + xfer += iprot->readI32(ecast640); + this->type = (LockType::type)ecast640; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15066,43 +15563,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other611) { - lockid = other611.lockid; - dbname = other611.dbname; - tablename = other611.tablename; - partname = other611.partname; - state = other611.state; - type = other611.type; - txnid = other611.txnid; - lastheartbeat = other611.lastheartbeat; - acquiredat = other611.acquiredat; - user = other611.user; - hostname = other611.hostname; - heartbeatCount = other611.heartbeatCount; - agentInfo = other611.agentInfo; - blockedByExtId = other611.blockedByExtId; - blockedByIntId = other611.blockedByIntId; - lockIdInternal = other611.lockIdInternal; - __isset = other611.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other612) { - lockid = other612.lockid; - dbname = other612.dbname; - tablename = other612.tablename; - partname = other612.partname; - state = other612.state; - type = other612.type; - txnid = other612.txnid; - lastheartbeat = other612.lastheartbeat; - acquiredat = other612.acquiredat; - user = other612.user; - hostname = other612.hostname; - heartbeatCount = other612.heartbeatCount; - agentInfo = other612.agentInfo; - blockedByExtId = other612.blockedByExtId; - blockedByIntId = other612.blockedByIntId; - lockIdInternal = other612.lockIdInternal; - __isset = other612.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other641) { + lockid = other641.lockid; + dbname = other641.dbname; + tablename = other641.tablename; + partname = other641.partname; + state = other641.state; + type = other641.type; + txnid = other641.txnid; + lastheartbeat = other641.lastheartbeat; + acquiredat = other641.acquiredat; + user = other641.user; + hostname = other641.hostname; + heartbeatCount = other641.heartbeatCount; + agentInfo = other641.agentInfo; + blockedByExtId = other641.blockedByExtId; + blockedByIntId = other641.blockedByIntId; + lockIdInternal = other641.lockIdInternal; + __isset = other641.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other642) { + lockid = other642.lockid; + dbname = other642.dbname; + tablename = other642.tablename; + partname = other642.partname; + state = other642.state; + type = other642.type; + txnid = other642.txnid; + lastheartbeat = other642.lastheartbeat; + acquiredat = other642.acquiredat; + user = other642.user; + hostname = other642.hostname; + heartbeatCount = other642.heartbeatCount; + agentInfo = other642.agentInfo; + blockedByExtId = other642.blockedByExtId; + blockedByIntId = other642.blockedByIntId; + lockIdInternal = other642.lockIdInternal; + __isset = other642.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -15161,14 +15658,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size613; - ::apache::thrift::protocol::TType _etype616; - xfer += iprot->readListBegin(_etype616, _size613); - this->locks.resize(_size613); - uint32_t _i617; - for (_i617 = 0; _i617 < _size613; ++_i617) + uint32_t _size643; + ::apache::thrift::protocol::TType _etype646; + xfer += iprot->readListBegin(_etype646, _size643); + this->locks.resize(_size643); + uint32_t _i647; + for (_i647 = 0; _i647 < _size643; ++_i647) { - xfer += this->locks[_i617].read(iprot); + xfer += this->locks[_i647].read(iprot); } xfer += iprot->readListEnd(); } @@ -15197,10 +15694,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 _iter618; - for (_iter618 = this->locks.begin(); _iter618 != this->locks.end(); ++_iter618) + std::vector<ShowLocksResponseElement> ::const_iterator _iter648; + for (_iter648 = this->locks.begin(); _iter648 != this->locks.end(); ++_iter648) { - xfer += (*_iter618).write(oprot); + xfer += (*_iter648).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15217,13 +15714,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other619) { - locks = other619.locks; - __isset = other619.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other649) { + locks = other649.locks; + __isset = other649.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other620) { - locks = other620.locks; - __isset = other620.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other650) { + locks = other650.locks; + __isset = other650.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -15324,15 +15821,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other621) { - lockid = other621.lockid; - txnid = other621.txnid; - __isset = other621.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other651) { + lockid = other651.lockid; + txnid = other651.txnid; + __isset = other651.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other622) { - lockid = other622.lockid; - txnid = other622.txnid; - __isset = other622.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other652) { + lockid = other652.lockid; + txnid = other652.txnid; + __isset = other652.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -15435,13 +15932,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other623) { - min = other623.min; - max = other623.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other653) { + min = other653.min; + max = other653.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other624) { - min = other624.min; - max = other624.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other654) { + min = other654.min; + max = other654.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -15492,15 +15989,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size625; - ::apache::thrift::protocol::TType _etype628; - xfer += iprot->readSetBegin(_etype628, _size625); - uint32_t _i629; - for (_i629 = 0; _i629 < _size625; ++_i629) + uint32_t _size655; + ::apache::thrift::protocol::TType _etype658; + xfer += iprot->readSetBegin(_etype658, _size655); + uint32_t _i659; + for (_i659 = 0; _i659 < _size655; ++_i659) { - int64_t _elem630; - xfer += iprot->readI64(_elem630); - this->aborted.insert(_elem630); + int64_t _elem660; + xfer += iprot->readI64(_elem660); + this->aborted.insert(_elem660); } xfer += iprot->readSetEnd(); } @@ -15513,15 +16010,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size631; - ::apache::thrift::protocol::TType _etype634; - xfer += iprot->readSetBegin(_etype634, _size631); - uint32_t _i635; - for (_i635 = 0; _i635 < _size631; ++_i635) + uint32_t _size661; + ::apache::thrift::protocol::TType _etype664; + xfer += iprot->readSetBegin(_etype664, _size661); + uint32_t _i665; + for (_i665 = 0; _i665 < _size661; ++_i665) { - int64_t _elem636; - xfer += iprot->readI64(_elem636); - this->nosuch.insert(_elem636); + int64_t _elem666; + xfer += iprot->readI64(_elem666); + this->nosuch.insert(_elem666); } xfer += iprot->readSetEnd(); } @@ -15554,10 +16051,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 _iter637; - for (_iter637 = this->aborted.begin(); _iter637 != this->aborted.end(); ++_iter637) + std::set<int64_t> ::const_iterator _iter667; + for (_iter667 = this->aborted.begin(); _iter667 != this->aborted.end(); ++_iter667) { - xfer += oprot->writeI64((*_iter637)); + xfer += oprot->writeI64((*_iter667)); } xfer += oprot->writeSetEnd(); } @@ -15566,10 +16063,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 _iter638; - for (_iter638 = this->nosuch.begin(); _iter638 != this->nosuch.end(); ++_iter638) + std::set<int64_t> ::const_iterator _iter668; + for (_iter668 = this->nosuch.begin(); _iter668 != this->nosuch.end(); ++_iter668) { - xfer += oprot->writeI64((*_iter638)); + xfer += oprot->writeI64((*_iter668)); } xfer += oprot->writeSetEnd(); } @@ -15586,13 +16083,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other639) { - aborted = other639.aborted; - nosuch = other639.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other669) { + aborted = other669.aborted; + nosuch = other669.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other640) { - aborted = other640.aborted; - nosuch = other640.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other670) { + aborted = other670.aborted; + nosuch = other670.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -15685,9 +16182,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast641; - xfer += iprot->readI32(ecast641); - this->type = (CompactionType::type)ecast641; + int32_t ecast671; + xfer += iprot->readI32(ecast671); + this->type = (CompactionType::type)ecast671; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15705,17 +16202,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size642; - ::apache::thrift::protocol::TType _ktype643; - ::apache::thrift::protocol::TType _vtype644; - xfer += iprot->readMapBegin(_ktype643, _vtype644, _size642); - uint32_t _i646; - for (_i646 = 0; _i646 < _size642; ++_i646) + uint32_t _size672; + ::apache::thrift::protocol::TType _ktype673; + ::apache::thrift::protocol::TType _vtype674; + xfer += iprot->readMapBegin(_ktype673, _vtype674, _size672); + uint32_t _i676; + for (_i676 = 0; _i676 < _size672; ++_i676) { - std::string _key647; - xfer += iprot->readString(_key647); - std::string& _val648 = this->properties[_key647]; - xfer += iprot->readString(_val648); + std::string _key677; + xfer += iprot->readString(_key677); + std::string& _val678 = this->properties[_key677]; + xfer += iprot->readString(_val678); } xfer += iprot->readMapEnd(); } @@ -15773,11 +16270,11 @@ uint32_t CompactionRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 6); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size())); - std::map<std::string, std::string> ::const_iterator _iter649; - for (_iter649 = this->properties.begin(); _iter649 != this->properties.end(); ++_iter649) + std::map<std::string, std::string> ::const_iterator _iter679; + for (_iter679 = this->properties.begin(); _iter679 != this->properties.end(); ++_iter679) { - xfer += oprot->writeString(_iter649->first); - xfer += oprot->writeString(_iter649->second); + xfer += oprot->writeString(_iter679->first); + xfer += oprot->writeString(_iter679->second); } xfer += oprot->writeMapEnd(); } @@ -15799,23 +16296,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other650) { - dbname = other650.dbname; - tablename = other650.tablename; - partitionname = other650.partitionname; - type = other650.type; - runas = other650.runas; - properties = other650.properties; - __isset = other650.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other651) { - dbname = other651.dbname; - tablename = other651.tablename; - partitionname = other651.partitionname; - type = other651.type; - runas = other651.runas; - properties = other651.properties; - __isset = other651.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other680) { + dbname = other680.dbname; + tablename = other680.tablename; + partitionname = other680.partitionname; + type = other680.type; + runas = other680.runas; + properties = other680.properties; + __isset = other680.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other681) { + dbname = other681.dbname; + tablename = other681.tablename; + partitionname = other681.partitionname; + type = other681.type; + runas = other681.runas; + properties = other681.properties; + __isset = other681.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -15942,15 +16439,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other652) { - id = other652.id; - state = other652.state; - accepted = other652.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other682) { + id = other682.id; + state = other682.state; + accepted = other682.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other653) { - id = other653.id; - state = other653.state; - accepted = other653.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other683) { + id = other683.id; + state = other683.state; + accepted = other683.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -16011,11 +16508,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other654) { - (void) other654; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other684) { + (void) other684; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other655) { - (void) other655; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other685) { + (void) other685; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -16141,9 +16638,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast656; - xfer += iprot->readI32(ecast656); - this->type = (CompactionType::type)ecast656; + int32_t ecast686; + xfer += iprot->readI32(ecast686); + this->type = (CompactionType::type)ecast686; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -16330,37 +16827,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other657) { - dbname = other657.dbname; - tablename = other657.tablename; - partitionname = other657.partitionname; - type = other657.type; - state = other657.state; - workerid = other657.workerid; - start = other657.start; - runAs = other657.runAs; - hightestTxnId = other657.hightestTxnId; - metaInfo = other657.metaInfo; - endTime = other657.endTime; - hadoopJobId = other657.hadoopJobId; - id = other657.id; - __isset = other657.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other658) { - dbname = other658.dbname; - tablename = other658.tablename; - partitionname = other658.partitionname; - type = other658.type; - state = other658.state; - workerid = other658.workerid; - start = other658.start; - runAs = other658.runAs; - hightestTxnId = other658.hightestTxnId; - metaInfo = other658.metaInfo; - endTime = other658.endTime; - hadoopJobId = other658.hadoopJobId; - id = other658.id; - __isset = other658.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other687) { + dbname = other687.dbname; + tablename = other687.tablename; + partitionname = other687.partitionname; + type = other687.type; + state = other687.state; + workerid = other687.workerid; + start = other687.start; + runAs = other687.runAs; + hightestTxnId = other687.hightestTxnId; + metaInfo = other687.metaInfo; + endTime = other687.endTime; + hadoopJobId = other687.hadoopJobId; + id = other687.id; + __isset = other687.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other688) { + dbname = other688.dbname; + tablename = other688.tablename; + partitionname = other688.partitionname; + type = other688.type; + state = other688.state; + workerid = other688.workerid; + start = other688.start; + runAs = other688.runAs; + hightestTxnId = other688.hightestTxnId; + metaInfo = other688.metaInfo; + endTime = other688.endTime; + hadoopJobId = other688.hadoopJobId; + id = other688.id; + __isset = other688.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -16417,14 +16914,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size659; - ::apache::thrift::protocol::TType _etype662; - xfer += iprot->readListBegin(_etype662, _size659); - this->compacts.resize(_size659); - uint32_t _i663; - for (_i663 = 0; _i663 < _size659; ++_i663) + uint32_t _size689; + ::apache::thrift::protocol::TType _etype692; + xfer += iprot->readListBegin(_etype692, _size689); + this->compacts.resize(_size689); + uint32_t _i693; + for (_i693 = 0; _i693 < _size689; ++_i693) { - xfer += this->compacts[_i663].read(iprot); + xfer += this->compacts[_i693].read(iprot); } xfer += iprot->readListEnd(); } @@ -16455,10 +16952,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 _iter664; - for (_iter664 = this->compacts.begin(); _iter664 != this->compacts.end(); ++_iter664) + std::vector<ShowCompactResponseElement> ::const_iterator _iter694; + for (_iter694 = this->compacts.begin(); _iter694 != this->compacts.end(); ++_iter694) { - xfer += (*_iter664).write(oprot); + xfer += (*_iter694).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16474,11 +16971,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other665) { - compacts = other665.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other695) { + compacts = other695.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other666) { - compacts = other666.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other696) { + compacts = other696.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -16567,14 +17064,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size667; - ::apache::thrift::protocol::TType _etype670; - xfer += iprot->readListBegin(_etype670, _size667); - this->partitionnames.resize(_size667); - uint32_t _i671; - for (_i671 = 0; _i671 < _size667; ++_i671) + uint32_t _size697; + ::apache::thrift::protocol::TType _etype700; + xfer += iprot->readListBegin(_etype700, _size697); + this->partitionnames.resize(_size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - xfer += iprot->readString(this->partitionnames[_i671]); + xfer += iprot->readString(this->partitionnames[_i701]); } xfer += iprot->readListEnd(); } @@ -16585,9 +17082,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast672; - xfer += iprot->readI32(ecast672); - this->operationType = (DataOperationType::type)ecast672; + int32_t ecast702; + xfer += iprot->readI32(ecast702); + this->operationType = (DataOperationType::type)ecast702; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -16633,10 +17130,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 _iter673; - for (_iter673 = this->partitionnames.begin(); _iter673 != this->partitionnames.end(); ++_iter673) + std::vector<std::string> ::const_iterator _iter703; + for (_iter703 = this->partitionnames.begin(); _iter703 != this->partitionnames.end(); ++_iter703) { - xfer += oprot->writeString((*_iter673)); + xfer += oprot->writeString((*_iter703)); } xfer += oprot->writeListEnd(); } @@ -16662,21 +17159,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other674) { - txnid = other674.txnid; - dbname = other674.dbname; - tablename = other674.tablename; - partitionnames = other674.partitionnames; - operationType = other674.operationType; - __isset = other674.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other675) { - txnid = other675.txnid; - dbname = other675.dbname; - tablename = other675.tablename; - partitionnames = other675.partitionnames; - operationType = other675.operationType; - __isset = other675.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other704) { + txnid = other704.txnid; + dbname = other704.dbname; + tablename = other704.tablename; + partitionnames = other704.partitionnames; + operationType = other704.operationType; + __isset = other704.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other705) { + txnid = other705.txnid; + dbname = other705.dbname; + tablename = other705.tablename; + partitionnames = other705.partitionnames; + operationType = other705.operationType; + __isset = other705.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -16782,15 +17279,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other676) { - lastEvent = other676.lastEvent; - maxEvents = other676.maxEvents; - __isset = other676.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other706) { + lastEvent = other706.lastEvent; + maxEvents = other706.maxEvents; + __isset = other706.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other677) { - lastEvent = other677.lastEvent; - maxEvents = other677.maxEvents; - __isset = other677.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other707) { + lastEvent = other707.lastEvent; + maxEvents = other707.maxEvents; + __isset = other707.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -16991,25 +17488,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other678) { - eventId = other678.eventId; - eventTime = other678.eventTime; - eventType = other678.eventType; - dbName = other678.dbName; - tableName = other678.tableName; - message = other678.message; - messageFormat = other678.messageFormat; - __isset = other678.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other679) { - eventId = other679.eventId; - eventTime = other679.eventTime; - eventType = other679.eventType; - dbName = other679.dbName; - tableName = other679.tableName; - message = other679.message; - messageFormat = other679.messageFormat; - __isset = other679.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other708) { + eventId = other708.eventId; + eventTime = other708.eventTime; + eventType = other708.eventType; + dbName = other708.dbName; + tableName = other708.tableName; + message = other708.message; + messageFormat = other708.messageFormat; + __isset = other708.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other709) { + eventId = other709.eventId; + eventTime = other709.eventTime; + eventType = other709.eventType; + dbName = other709.dbName; + tableName = other709.tableName; + message = other709.message; + messageFormat = other709.messageFormat; + __isset = other709.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -17060,14 +17557,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size680; - ::apache::thrift::protocol::TType _etype683; - xfer += iprot->readListBegin(_etype683, _size680); - this->events.resize(_size680); - uint32_t _i684; - for (_i684 = 0; _i684 < _size680; ++_i684) + uint32_t _size710; + ::apache::thrift::protocol::TType _etype713; + xfer += iprot->readListBegin(_etype713, _size710); + this->events.resize(_size710); + uint32_t _i714; + for (_i714 = 0; _i714 < _size710; ++_i714) { - xfer += this->events[_i684].read(iprot); + xfer += this->events[_i714].read(iprot); } xfer += iprot->readListEnd(); } @@ -17098,10 +17595,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->events.size())); - std::vector<NotificationEvent> ::const_iterator _iter685; - for (_iter685 = this->events.begin(); _iter685 != this->events.end(); ++_iter685) + std::vector<NotificationEvent> ::const_iterator _iter715; + for (_iter715 = this->events.begin(); _iter715 != this->events.end(); ++_iter715) { - xfer += (*_iter685).write(oprot); + xfer += (*_iter715).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17117,11 +17614,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other686) { - events = other686.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other716) { + events = other716.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other687) { - events = other687.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other717) { + events = other717.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -17203,11 +17700,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other688) { - eventId = other688.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other718) { + eventId = other718.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other689) { - eventId = other689.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other719) { + eventId = other719.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -17309,13 +17806,13 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.dbName, b.dbName); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other690) { - fromEventId = other690.fromEventId; - dbName = other690.dbName; +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other720) { + fromEventId = other720.fromEventId; + dbName = other720.dbName; } -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other691) { - fromEventId = other691.fromEventId; - dbName = other691.dbName; +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other721) { + fromEventId = other721.fromEventId; + dbName = other721.dbName; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -17398,11 +17895,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other692) { - eventsCount = other692.eventsCount; +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other722) { + eventsCount = other722.eventsCount; } -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other693) { - eventsCount = other693.eventsCount; +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other723) { + eventsCount = other723.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -17465,14 +17962,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size694; - ::apache::thrift::protocol::TType _etype697; - xfer += iprot->readListBegin(_etype697, _size694); - this->filesAdded.resize(_size694); - uint32_t _i698; - for (_i698 = 0; _i698 < _size694; ++_i698) + uint32_t _size724; + ::apache::thrift::protocol::TType _etype727; + xfer += iprot->readListBegin(_etype727, _size724); + this->filesAdded.resize(_size724); + uint32_t _i728; + for (_i728 = 0; _i728 < _size724; ++_i728) { - xfer += iprot->readString(this->filesAdded[_i698]); + xfer += iprot->readString(this->filesAdded[_i728]); } xfer += iprot->readListEnd(); } @@ -17485,14 +17982,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size699; - ::apache::thrift::protocol::TType _etype702; - xfer += iprot->readListBegin(_etype702, _size699); - this->filesAddedChecksum.resize(_size699); - uint32_t _i703; - for (_i703 = 0; _i703 < _size699; ++_i703) + uint32_t _size729; + ::apache::thrift::protocol::TType _etype732; + xfer += iprot->readListBegin(_etype732, _size729); + this->filesAddedChecksum.resize(_size729); + uint32_t _i733; + for (_i733 = 0; _i733 < _size729; ++_i733) { - xfer += iprot->readString(this->filesAddedChecksum[_i703]); + xfer += iprot->readString(this->filesAddedChecksum[_i733]); } xfer += iprot->readListEnd(); } @@ -17528,10 +18025,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size())); - std::vector<std::string> ::const_iterator _iter704; - for (_iter704 = this->filesAdded.begin(); _iter704 != this->filesAdded.end(); ++_iter704) + std::vector<std::string> ::const_iterator _iter734; + for (_iter734 = this->filesAdded.begin(); _iter734 != this->filesAdded.end(); ++_iter734) { - xfer += oprot->writeString((*_iter704)); + xfer += oprot->writeString((*_iter734)); } xfer += oprot->writeListEnd(); } @@ -17541,10 +18038,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size())); - std::vector<std::string> ::const_iterator _iter705; - for (_iter705 = this->filesAddedChecksum.begin(); _iter705 != this->filesAddedChecksum.end(); ++_iter705) + std::vector<std::string> ::const_iterator _iter735; + for (_iter735 = this->filesAddedChecksum.begin(); _iter735 != this->filesAddedChecksum.end(); ++_iter735) { - xfer += oprot->writeString((*_iter705)); + xfer += oprot->writeString((*_iter735)); } xfer += oprot->writeListEnd(); } @@ -17563,17 +18060,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other706) { - replace = other706.replace; - filesAdded = other706.filesAdded; - filesAddedChecksum = other706.filesAddedChecksum; - __isset = other706.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other736) { + replace = other736.replace; + filesAdded = other736.filesAdded; + filesAddedChecksum = other736.filesAddedChecksum; + __isset = other736.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other707) { - replace = other707.replace; - filesAdded = other707.filesAdded; - filesAddedChecksum = other707.filesAddedChecksum; - __isset = other707.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other737) { + replace = other737.replace; + filesAdded = other737.filesAdded; + filesAddedChecksum = other737.filesAddedChecksum; + __isset = other737.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -17655,13 +18152,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other708) { - insertData = other708.insertData; - __isset = other708.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other738) { + insertData = other738.insertData; + __isset = other738.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other709) { - insertData = other709.insertData; - __isset = other709.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other739) { + insertData = other739.insertData; + __isset = other739.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -17758,14 +18255,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.cl
<TRUNCATED>
