http://git-wip-us.apache.org/repos/asf/hive/blob/59483bca/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 987a4f3..383cb9b 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 @@ -15906,6 +15906,16 @@ void OpenTxnRequest::__set_agentInfo(const std::string& val) { __isset.agentInfo = true; } +void OpenTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + +void OpenTxnRequest::__set_replSrcTxnIds(const std::vector<int64_t> & val) { + this->replSrcTxnIds = val; +__isset.replSrcTxnIds = true; +} + uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -15962,6 +15972,34 @@ uint32_t OpenTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 6: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->replSrcTxnIds.clear(); + uint32_t _size644; + ::apache::thrift::protocol::TType _etype647; + xfer += iprot->readListBegin(_etype647, _size644); + this->replSrcTxnIds.resize(_size644); + uint32_t _i648; + for (_i648 = 0; _i648 < _size644; ++_i648) + { + xfer += iprot->readI64(this->replSrcTxnIds[_i648]); + } + xfer += iprot->readListEnd(); + } + this->__isset.replSrcTxnIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -16002,6 +16040,24 @@ uint32_t OpenTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) con xfer += oprot->writeString(this->agentInfo); xfer += oprot->writeFieldEnd(); } + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } + if (this->__isset.replSrcTxnIds) { + xfer += oprot->writeFieldBegin("replSrcTxnIds", ::apache::thrift::protocol::T_LIST, 6); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->replSrcTxnIds.size())); + std::vector<int64_t> ::const_iterator _iter649; + for (_iter649 = this->replSrcTxnIds.begin(); _iter649 != this->replSrcTxnIds.end(); ++_iter649) + { + xfer += oprot->writeI64((*_iter649)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -16013,22 +16069,28 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.user, b.user); swap(a.hostname, b.hostname); swap(a.agentInfo, b.agentInfo); + swap(a.replPolicy, b.replPolicy); + swap(a.replSrcTxnIds, b.replSrcTxnIds); swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other644) { - num_txns = other644.num_txns; - user = other644.user; - hostname = other644.hostname; - agentInfo = other644.agentInfo; - __isset = other644.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other645) { - num_txns = other645.num_txns; - user = other645.user; - hostname = other645.hostname; - agentInfo = other645.agentInfo; - __isset = other645.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other650) { + num_txns = other650.num_txns; + user = other650.user; + hostname = other650.hostname; + agentInfo = other650.agentInfo; + replPolicy = other650.replPolicy; + replSrcTxnIds = other650.replSrcTxnIds; + __isset = other650.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other651) { + num_txns = other651.num_txns; + user = other651.user; + hostname = other651.hostname; + agentInfo = other651.agentInfo; + replPolicy = other651.replPolicy; + replSrcTxnIds = other651.replSrcTxnIds; + __isset = other651.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -16038,6 +16100,8 @@ void OpenTxnRequest::printTo(std::ostream& out) const { out << ", " << "user=" << to_string(user); out << ", " << "hostname=" << to_string(hostname); out << ", " << "agentInfo="; (__isset.agentInfo ? (out << to_string(agentInfo)) : (out << "<null>")); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "<null>")); + out << ", " << "replSrcTxnIds="; (__isset.replSrcTxnIds ? (out << to_string(replSrcTxnIds)) : (out << "<null>")); out << ")"; } @@ -16076,14 +16140,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size646; - ::apache::thrift::protocol::TType _etype649; - xfer += iprot->readListBegin(_etype649, _size646); - this->txn_ids.resize(_size646); - uint32_t _i650; - for (_i650 = 0; _i650 < _size646; ++_i650) + uint32_t _size652; + ::apache::thrift::protocol::TType _etype655; + xfer += iprot->readListBegin(_etype655, _size652); + this->txn_ids.resize(_size652); + uint32_t _i656; + for (_i656 = 0; _i656 < _size652; ++_i656) { - xfer += iprot->readI64(this->txn_ids[_i650]); + xfer += iprot->readI64(this->txn_ids[_i656]); } xfer += iprot->readListEnd(); } @@ -16114,10 +16178,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 _iter651; - for (_iter651 = this->txn_ids.begin(); _iter651 != this->txn_ids.end(); ++_iter651) + std::vector<int64_t> ::const_iterator _iter657; + for (_iter657 = this->txn_ids.begin(); _iter657 != this->txn_ids.end(); ++_iter657) { - xfer += oprot->writeI64((*_iter651)); + xfer += oprot->writeI64((*_iter657)); } xfer += oprot->writeListEnd(); } @@ -16133,11 +16197,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other652) { - txn_ids = other652.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other658) { + txn_ids = other658.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other653) { - txn_ids = other653.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other659) { + txn_ids = other659.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -16156,6 +16220,11 @@ void AbortTxnRequest::__set_txnid(const int64_t val) { this->txnid = val; } +void AbortTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -16186,6 +16255,14 @@ uint32_t AbortTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -16209,6 +16286,11 @@ uint32_t AbortTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeI64(this->txnid); xfer += oprot->writeFieldEnd(); + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -16217,19 +16299,26 @@ uint32_t AbortTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) co void swap(AbortTxnRequest &a, AbortTxnRequest &b) { using ::std::swap; swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.__isset, b.__isset); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other654) { - txnid = other654.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other660) { + txnid = other660.txnid; + replPolicy = other660.replPolicy; + __isset = other660.__isset; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other655) { - txnid = other655.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other661) { + txnid = other661.txnid; + replPolicy = other661.replPolicy; + __isset = other661.__isset; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "AbortTxnRequest("; out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "<null>")); out << ")"; } @@ -16268,14 +16357,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size656; - ::apache::thrift::protocol::TType _etype659; - xfer += iprot->readListBegin(_etype659, _size656); - this->txn_ids.resize(_size656); - uint32_t _i660; - for (_i660 = 0; _i660 < _size656; ++_i660) + uint32_t _size662; + ::apache::thrift::protocol::TType _etype665; + xfer += iprot->readListBegin(_etype665, _size662); + this->txn_ids.resize(_size662); + uint32_t _i666; + for (_i666 = 0; _i666 < _size662; ++_i666) { - xfer += iprot->readI64(this->txn_ids[_i660]); + xfer += iprot->readI64(this->txn_ids[_i666]); } xfer += iprot->readListEnd(); } @@ -16306,10 +16395,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 _iter661; - for (_iter661 = this->txn_ids.begin(); _iter661 != this->txn_ids.end(); ++_iter661) + std::vector<int64_t> ::const_iterator _iter667; + for (_iter667 = this->txn_ids.begin(); _iter667 != this->txn_ids.end(); ++_iter667) { - xfer += oprot->writeI64((*_iter661)); + xfer += oprot->writeI64((*_iter667)); } xfer += oprot->writeListEnd(); } @@ -16325,11 +16414,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other662) { - txn_ids = other662.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other668) { + txn_ids = other668.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other663) { - txn_ids = other663.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other669) { + txn_ids = other669.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -16348,6 +16437,11 @@ void CommitTxnRequest::__set_txnid(const int64_t val) { this->txnid = val; } +void CommitTxnRequest::__set_replPolicy(const std::string& val) { + this->replPolicy = val; +__isset.replPolicy = true; +} + uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -16378,6 +16472,14 @@ uint32_t CommitTxnRequest::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->replPolicy); + this->__isset.replPolicy = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -16401,6 +16503,11 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeI64(this->txnid); xfer += oprot->writeFieldEnd(); + if (this->__isset.replPolicy) { + xfer += oprot->writeFieldBegin("replPolicy", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->replPolicy); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -16409,19 +16516,26 @@ uint32_t CommitTxnRequest::write(::apache::thrift::protocol::TProtocol* oprot) c void swap(CommitTxnRequest &a, CommitTxnRequest &b) { using ::std::swap; swap(a.txnid, b.txnid); + swap(a.replPolicy, b.replPolicy); + swap(a.__isset, b.__isset); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other664) { - txnid = other664.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other670) { + txnid = other670.txnid; + replPolicy = other670.replPolicy; + __isset = other670.__isset; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other665) { - txnid = other665.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other671) { + txnid = other671.txnid; + replPolicy = other671.replPolicy; + __isset = other671.__isset; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "CommitTxnRequest("; out << "txnid=" << to_string(txnid); + out << ", " << "replPolicy="; (__isset.replPolicy ? (out << to_string(replPolicy)) : (out << "<null>")); out << ")"; } @@ -16465,14 +16579,14 @@ uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fullTableNames.clear(); - uint32_t _size666; - ::apache::thrift::protocol::TType _etype669; - xfer += iprot->readListBegin(_etype669, _size666); - this->fullTableNames.resize(_size666); - uint32_t _i670; - for (_i670 = 0; _i670 < _size666; ++_i670) + uint32_t _size672; + ::apache::thrift::protocol::TType _etype675; + xfer += iprot->readListBegin(_etype675, _size672); + this->fullTableNames.resize(_size672); + uint32_t _i676; + for (_i676 = 0; _i676 < _size672; ++_i676) { - xfer += iprot->readString(this->fullTableNames[_i670]); + xfer += iprot->readString(this->fullTableNames[_i676]); } xfer += iprot->readListEnd(); } @@ -16513,10 +16627,10 @@ uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("fullTableNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->fullTableNames.size())); - std::vector<std::string> ::const_iterator _iter671; - for (_iter671 = this->fullTableNames.begin(); _iter671 != this->fullTableNames.end(); ++_iter671) + std::vector<std::string> ::const_iterator _iter677; + for (_iter677 = this->fullTableNames.begin(); _iter677 != this->fullTableNames.end(); ++_iter677) { - xfer += oprot->writeString((*_iter671)); + xfer += oprot->writeString((*_iter677)); } xfer += oprot->writeListEnd(); } @@ -16537,13 +16651,13 @@ void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) { swap(a.validTxnList, b.validTxnList); } -GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other672) { - fullTableNames = other672.fullTableNames; - validTxnList = other672.validTxnList; +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other678) { + fullTableNames = other678.fullTableNames; + validTxnList = other678.validTxnList; } -GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other673) { - fullTableNames = other673.fullTableNames; - validTxnList = other673.validTxnList; +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other679) { + fullTableNames = other679.fullTableNames; + validTxnList = other679.validTxnList; return *this; } void GetValidWriteIdsRequest::printTo(std::ostream& out) const { @@ -16625,14 +16739,14 @@ uint32_t TableValidWriteIds::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->invalidWriteIds.clear(); - uint32_t _size674; - ::apache::thrift::protocol::TType _etype677; - xfer += iprot->readListBegin(_etype677, _size674); - this->invalidWriteIds.resize(_size674); - uint32_t _i678; - for (_i678 = 0; _i678 < _size674; ++_i678) + uint32_t _size680; + ::apache::thrift::protocol::TType _etype683; + xfer += iprot->readListBegin(_etype683, _size680); + this->invalidWriteIds.resize(_size680); + uint32_t _i684; + for (_i684 = 0; _i684 < _size680; ++_i684) { - xfer += iprot->readI64(this->invalidWriteIds[_i678]); + xfer += iprot->readI64(this->invalidWriteIds[_i684]); } xfer += iprot->readListEnd(); } @@ -16693,10 +16807,10 @@ uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("invalidWriteIds", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->invalidWriteIds.size())); - std::vector<int64_t> ::const_iterator _iter679; - for (_iter679 = this->invalidWriteIds.begin(); _iter679 != this->invalidWriteIds.end(); ++_iter679) + std::vector<int64_t> ::const_iterator _iter685; + for (_iter685 = this->invalidWriteIds.begin(); _iter685 != this->invalidWriteIds.end(); ++_iter685) { - xfer += oprot->writeI64((*_iter679)); + xfer += oprot->writeI64((*_iter685)); } xfer += oprot->writeListEnd(); } @@ -16726,21 +16840,21 @@ void swap(TableValidWriteIds &a, TableValidWriteIds &b) { swap(a.__isset, b.__isset); } -TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other680) { - fullTableName = other680.fullTableName; - writeIdHighWaterMark = other680.writeIdHighWaterMark; - invalidWriteIds = other680.invalidWriteIds; - minOpenWriteId = other680.minOpenWriteId; - abortedBits = other680.abortedBits; - __isset = other680.__isset; -} -TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other681) { - fullTableName = other681.fullTableName; - writeIdHighWaterMark = other681.writeIdHighWaterMark; - invalidWriteIds = other681.invalidWriteIds; - minOpenWriteId = other681.minOpenWriteId; - abortedBits = other681.abortedBits; - __isset = other681.__isset; +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other686) { + fullTableName = other686.fullTableName; + writeIdHighWaterMark = other686.writeIdHighWaterMark; + invalidWriteIds = other686.invalidWriteIds; + minOpenWriteId = other686.minOpenWriteId; + abortedBits = other686.abortedBits; + __isset = other686.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other687) { + fullTableName = other687.fullTableName; + writeIdHighWaterMark = other687.writeIdHighWaterMark; + invalidWriteIds = other687.invalidWriteIds; + minOpenWriteId = other687.minOpenWriteId; + abortedBits = other687.abortedBits; + __isset = other687.__isset; return *this; } void TableValidWriteIds::printTo(std::ostream& out) const { @@ -16789,14 +16903,14 @@ uint32_t GetValidWriteIdsResponse::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblValidWriteIds.clear(); - uint32_t _size682; - ::apache::thrift::protocol::TType _etype685; - xfer += iprot->readListBegin(_etype685, _size682); - this->tblValidWriteIds.resize(_size682); - uint32_t _i686; - for (_i686 = 0; _i686 < _size682; ++_i686) + uint32_t _size688; + ::apache::thrift::protocol::TType _etype691; + xfer += iprot->readListBegin(_etype691, _size688); + this->tblValidWriteIds.resize(_size688); + uint32_t _i692; + for (_i692 = 0; _i692 < _size688; ++_i692) { - xfer += this->tblValidWriteIds[_i686].read(iprot); + xfer += this->tblValidWriteIds[_i692].read(iprot); } xfer += iprot->readListEnd(); } @@ -16827,10 +16941,10 @@ uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("tblValidWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tblValidWriteIds.size())); - std::vector<TableValidWriteIds> ::const_iterator _iter687; - for (_iter687 = this->tblValidWriteIds.begin(); _iter687 != this->tblValidWriteIds.end(); ++_iter687) + std::vector<TableValidWriteIds> ::const_iterator _iter693; + for (_iter693 = this->tblValidWriteIds.begin(); _iter693 != this->tblValidWriteIds.end(); ++_iter693) { - xfer += (*_iter687).write(oprot); + xfer += (*_iter693).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16846,11 +16960,11 @@ void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) { swap(a.tblValidWriteIds, b.tblValidWriteIds); } -GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other688) { - tblValidWriteIds = other688.tblValidWriteIds; +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other694) { + tblValidWriteIds = other694.tblValidWriteIds; } -GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other689) { - tblValidWriteIds = other689.tblValidWriteIds; +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other695) { + tblValidWriteIds = other695.tblValidWriteIds; return *this; } void GetValidWriteIdsResponse::printTo(std::ostream& out) const { @@ -16905,14 +17019,14 @@ uint32_t AllocateTableWriteIdsRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnIds.clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - this->txnIds.resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size696; + ::apache::thrift::protocol::TType _etype699; + xfer += iprot->readListBegin(_etype699, _size696); + this->txnIds.resize(_size696); + uint32_t _i700; + for (_i700 = 0; _i700 < _size696; ++_i700) { - xfer += iprot->readI64(this->txnIds[_i694]); + xfer += iprot->readI64(this->txnIds[_i700]); } xfer += iprot->readListEnd(); } @@ -16963,10 +17077,10 @@ uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("txnIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txnIds.size())); - std::vector<int64_t> ::const_iterator _iter695; - for (_iter695 = this->txnIds.begin(); _iter695 != this->txnIds.end(); ++_iter695) + std::vector<int64_t> ::const_iterator _iter701; + for (_iter701 = this->txnIds.begin(); _iter701 != this->txnIds.end(); ++_iter701) { - xfer += oprot->writeI64((*_iter695)); + xfer += oprot->writeI64((*_iter701)); } xfer += oprot->writeListEnd(); } @@ -16992,15 +17106,15 @@ void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) { swap(a.tableName, b.tableName); } -AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other696) { - txnIds = other696.txnIds; - dbName = other696.dbName; - tableName = other696.tableName; +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other702) { + txnIds = other702.txnIds; + dbName = other702.dbName; + tableName = other702.tableName; } -AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other697) { - txnIds = other697.txnIds; - dbName = other697.dbName; - tableName = other697.tableName; +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other703) { + txnIds = other703.txnIds; + dbName = other703.dbName; + tableName = other703.tableName; return *this; } void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { @@ -17104,13 +17218,13 @@ void swap(TxnToWriteId &a, TxnToWriteId &b) { swap(a.writeId, b.writeId); } -TxnToWriteId::TxnToWriteId(const TxnToWriteId& other698) { - txnId = other698.txnId; - writeId = other698.writeId; +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other704) { + txnId = other704.txnId; + writeId = other704.writeId; } -TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other699) { - txnId = other699.txnId; - writeId = other699.writeId; +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other705) { + txnId = other705.txnId; + writeId = other705.writeId; return *this; } void TxnToWriteId::printTo(std::ostream& out) const { @@ -17156,14 +17270,14 @@ uint32_t AllocateTableWriteIdsResponse::read(::apache::thrift::protocol::TProtoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txnToWriteIds.clear(); - uint32_t _size700; - ::apache::thrift::protocol::TType _etype703; - xfer += iprot->readListBegin(_etype703, _size700); - this->txnToWriteIds.resize(_size700); - uint32_t _i704; - for (_i704 = 0; _i704 < _size700; ++_i704) + uint32_t _size706; + ::apache::thrift::protocol::TType _etype709; + xfer += iprot->readListBegin(_etype709, _size706); + this->txnToWriteIds.resize(_size706); + uint32_t _i710; + for (_i710 = 0; _i710 < _size706; ++_i710) { - xfer += this->txnToWriteIds[_i704].read(iprot); + xfer += this->txnToWriteIds[_i710].read(iprot); } xfer += iprot->readListEnd(); } @@ -17194,10 +17308,10 @@ uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProto xfer += oprot->writeFieldBegin("txnToWriteIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->txnToWriteIds.size())); - std::vector<TxnToWriteId> ::const_iterator _iter705; - for (_iter705 = this->txnToWriteIds.begin(); _iter705 != this->txnToWriteIds.end(); ++_iter705) + std::vector<TxnToWriteId> ::const_iterator _iter711; + for (_iter711 = this->txnToWriteIds.begin(); _iter711 != this->txnToWriteIds.end(); ++_iter711) { - xfer += (*_iter705).write(oprot); + xfer += (*_iter711).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17213,11 +17327,11 @@ void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) { swap(a.txnToWriteIds, b.txnToWriteIds); } -AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other706) { - txnToWriteIds = other706.txnToWriteIds; +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other712) { + txnToWriteIds = other712.txnToWriteIds; } -AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other707) { - txnToWriteIds = other707.txnToWriteIds; +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other713) { + txnToWriteIds = other713.txnToWriteIds; return *this; } void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { @@ -17295,9 +17409,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast708; - xfer += iprot->readI32(ecast708); - this->type = (LockType::type)ecast708; + int32_t ecast714; + xfer += iprot->readI32(ecast714); + this->type = (LockType::type)ecast714; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -17305,9 +17419,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast709; - xfer += iprot->readI32(ecast709); - this->level = (LockLevel::type)ecast709; + int32_t ecast715; + xfer += iprot->readI32(ecast715); + this->level = (LockLevel::type)ecast715; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -17339,9 +17453,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast710; - xfer += iprot->readI32(ecast710); - this->operationType = (DataOperationType::type)ecast710; + int32_t ecast716; + xfer += iprot->readI32(ecast716); + this->operationType = (DataOperationType::type)ecast716; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -17441,27 +17555,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other711) { - type = other711.type; - level = other711.level; - dbname = other711.dbname; - tablename = other711.tablename; - partitionname = other711.partitionname; - operationType = other711.operationType; - isTransactional = other711.isTransactional; - isDynamicPartitionWrite = other711.isDynamicPartitionWrite; - __isset = other711.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other712) { - type = other712.type; - level = other712.level; - dbname = other712.dbname; - tablename = other712.tablename; - partitionname = other712.partitionname; - operationType = other712.operationType; - isTransactional = other712.isTransactional; - isDynamicPartitionWrite = other712.isDynamicPartitionWrite; - __isset = other712.__isset; +LockComponent::LockComponent(const LockComponent& other717) { + type = other717.type; + level = other717.level; + dbname = other717.dbname; + tablename = other717.tablename; + partitionname = other717.partitionname; + operationType = other717.operationType; + isTransactional = other717.isTransactional; + isDynamicPartitionWrite = other717.isDynamicPartitionWrite; + __isset = other717.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other718) { + type = other718.type; + level = other718.level; + dbname = other718.dbname; + tablename = other718.tablename; + partitionname = other718.partitionname; + operationType = other718.operationType; + isTransactional = other718.isTransactional; + isDynamicPartitionWrite = other718.isDynamicPartitionWrite; + __isset = other718.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -17533,14 +17647,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size713; - ::apache::thrift::protocol::TType _etype716; - xfer += iprot->readListBegin(_etype716, _size713); - this->component.resize(_size713); - uint32_t _i717; - for (_i717 = 0; _i717 < _size713; ++_i717) + uint32_t _size719; + ::apache::thrift::protocol::TType _etype722; + xfer += iprot->readListBegin(_etype722, _size719); + this->component.resize(_size719); + uint32_t _i723; + for (_i723 = 0; _i723 < _size719; ++_i723) { - xfer += this->component[_i717].read(iprot); + xfer += this->component[_i723].read(iprot); } xfer += iprot->readListEnd(); } @@ -17607,10 +17721,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 _iter718; - for (_iter718 = this->component.begin(); _iter718 != this->component.end(); ++_iter718) + std::vector<LockComponent> ::const_iterator _iter724; + for (_iter724 = this->component.begin(); _iter724 != this->component.end(); ++_iter724) { - xfer += (*_iter718).write(oprot); + xfer += (*_iter724).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17649,21 +17763,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other719) { - component = other719.component; - txnid = other719.txnid; - user = other719.user; - hostname = other719.hostname; - agentInfo = other719.agentInfo; - __isset = other719.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other720) { - component = other720.component; - txnid = other720.txnid; - user = other720.user; - hostname = other720.hostname; - agentInfo = other720.agentInfo; - __isset = other720.__isset; +LockRequest::LockRequest(const LockRequest& other725) { + component = other725.component; + txnid = other725.txnid; + user = other725.user; + hostname = other725.hostname; + agentInfo = other725.agentInfo; + __isset = other725.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other726) { + component = other726.component; + txnid = other726.txnid; + user = other726.user; + hostname = other726.hostname; + agentInfo = other726.agentInfo; + __isset = other726.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -17723,9 +17837,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast721; - xfer += iprot->readI32(ecast721); - this->state = (LockState::type)ecast721; + int32_t ecast727; + xfer += iprot->readI32(ecast727); + this->state = (LockState::type)ecast727; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -17771,13 +17885,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other722) { - lockid = other722.lockid; - state = other722.state; +LockResponse::LockResponse(const LockResponse& other728) { + lockid = other728.lockid; + state = other728.state; } -LockResponse& LockResponse::operator=(const LockResponse& other723) { - lockid = other723.lockid; - state = other723.state; +LockResponse& LockResponse::operator=(const LockResponse& other729) { + lockid = other729.lockid; + state = other729.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -17899,17 +18013,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other724) { - lockid = other724.lockid; - txnid = other724.txnid; - elapsed_ms = other724.elapsed_ms; - __isset = other724.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other730) { + lockid = other730.lockid; + txnid = other730.txnid; + elapsed_ms = other730.elapsed_ms; + __isset = other730.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other725) { - lockid = other725.lockid; - txnid = other725.txnid; - elapsed_ms = other725.elapsed_ms; - __isset = other725.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other731) { + lockid = other731.lockid; + txnid = other731.txnid; + elapsed_ms = other731.elapsed_ms; + __isset = other731.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -17993,11 +18107,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other726) { - lockid = other726.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other732) { + lockid = other732.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other727) { - lockid = other727.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other733) { + lockid = other733.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -18136,19 +18250,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other728) { - dbname = other728.dbname; - tablename = other728.tablename; - partname = other728.partname; - isExtended = other728.isExtended; - __isset = other728.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other734) { + dbname = other734.dbname; + tablename = other734.tablename; + partname = other734.partname; + isExtended = other734.isExtended; + __isset = other734.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other729) { - dbname = other729.dbname; - tablename = other729.tablename; - partname = other729.partname; - isExtended = other729.isExtended; - __isset = other729.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other735) { + dbname = other735.dbname; + tablename = other735.tablename; + partname = other735.partname; + isExtended = other735.isExtended; + __isset = other735.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -18301,9 +18415,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast730; - xfer += iprot->readI32(ecast730); - this->state = (LockState::type)ecast730; + int32_t ecast736; + xfer += iprot->readI32(ecast736); + this->state = (LockState::type)ecast736; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -18311,9 +18425,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast731; - xfer += iprot->readI32(ecast731); - this->type = (LockType::type)ecast731; + int32_t ecast737; + xfer += iprot->readI32(ecast737); + this->type = (LockType::type)ecast737; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -18529,43 +18643,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other732) { - lockid = other732.lockid; - dbname = other732.dbname; - tablename = other732.tablename; - partname = other732.partname; - state = other732.state; - type = other732.type; - txnid = other732.txnid; - lastheartbeat = other732.lastheartbeat; - acquiredat = other732.acquiredat; - user = other732.user; - hostname = other732.hostname; - heartbeatCount = other732.heartbeatCount; - agentInfo = other732.agentInfo; - blockedByExtId = other732.blockedByExtId; - blockedByIntId = other732.blockedByIntId; - lockIdInternal = other732.lockIdInternal; - __isset = other732.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other733) { - lockid = other733.lockid; - dbname = other733.dbname; - tablename = other733.tablename; - partname = other733.partname; - state = other733.state; - type = other733.type; - txnid = other733.txnid; - lastheartbeat = other733.lastheartbeat; - acquiredat = other733.acquiredat; - user = other733.user; - hostname = other733.hostname; - heartbeatCount = other733.heartbeatCount; - agentInfo = other733.agentInfo; - blockedByExtId = other733.blockedByExtId; - blockedByIntId = other733.blockedByIntId; - lockIdInternal = other733.lockIdInternal; - __isset = other733.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other738) { + lockid = other738.lockid; + dbname = other738.dbname; + tablename = other738.tablename; + partname = other738.partname; + state = other738.state; + type = other738.type; + txnid = other738.txnid; + lastheartbeat = other738.lastheartbeat; + acquiredat = other738.acquiredat; + user = other738.user; + hostname = other738.hostname; + heartbeatCount = other738.heartbeatCount; + agentInfo = other738.agentInfo; + blockedByExtId = other738.blockedByExtId; + blockedByIntId = other738.blockedByIntId; + lockIdInternal = other738.lockIdInternal; + __isset = other738.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other739) { + lockid = other739.lockid; + dbname = other739.dbname; + tablename = other739.tablename; + partname = other739.partname; + state = other739.state; + type = other739.type; + txnid = other739.txnid; + lastheartbeat = other739.lastheartbeat; + acquiredat = other739.acquiredat; + user = other739.user; + hostname = other739.hostname; + heartbeatCount = other739.heartbeatCount; + agentInfo = other739.agentInfo; + blockedByExtId = other739.blockedByExtId; + blockedByIntId = other739.blockedByIntId; + lockIdInternal = other739.lockIdInternal; + __isset = other739.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -18624,14 +18738,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size734; - ::apache::thrift::protocol::TType _etype737; - xfer += iprot->readListBegin(_etype737, _size734); - this->locks.resize(_size734); - uint32_t _i738; - for (_i738 = 0; _i738 < _size734; ++_i738) + uint32_t _size740; + ::apache::thrift::protocol::TType _etype743; + xfer += iprot->readListBegin(_etype743, _size740); + this->locks.resize(_size740); + uint32_t _i744; + for (_i744 = 0; _i744 < _size740; ++_i744) { - xfer += this->locks[_i738].read(iprot); + xfer += this->locks[_i744].read(iprot); } xfer += iprot->readListEnd(); } @@ -18660,10 +18774,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 _iter739; - for (_iter739 = this->locks.begin(); _iter739 != this->locks.end(); ++_iter739) + std::vector<ShowLocksResponseElement> ::const_iterator _iter745; + for (_iter745 = this->locks.begin(); _iter745 != this->locks.end(); ++_iter745) { - xfer += (*_iter739).write(oprot); + xfer += (*_iter745).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18680,13 +18794,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other740) { - locks = other740.locks; - __isset = other740.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other746) { + locks = other746.locks; + __isset = other746.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other741) { - locks = other741.locks; - __isset = other741.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other747) { + locks = other747.locks; + __isset = other747.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -18787,15 +18901,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other742) { - lockid = other742.lockid; - txnid = other742.txnid; - __isset = other742.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other748) { + lockid = other748.lockid; + txnid = other748.txnid; + __isset = other748.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other743) { - lockid = other743.lockid; - txnid = other743.txnid; - __isset = other743.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other749) { + lockid = other749.lockid; + txnid = other749.txnid; + __isset = other749.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -18898,13 +19012,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other744) { - min = other744.min; - max = other744.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other750) { + min = other750.min; + max = other750.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other745) { - min = other745.min; - max = other745.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other751) { + min = other751.min; + max = other751.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -18955,15 +19069,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size746; - ::apache::thrift::protocol::TType _etype749; - xfer += iprot->readSetBegin(_etype749, _size746); - uint32_t _i750; - for (_i750 = 0; _i750 < _size746; ++_i750) + uint32_t _size752; + ::apache::thrift::protocol::TType _etype755; + xfer += iprot->readSetBegin(_etype755, _size752); + uint32_t _i756; + for (_i756 = 0; _i756 < _size752; ++_i756) { - int64_t _elem751; - xfer += iprot->readI64(_elem751); - this->aborted.insert(_elem751); + int64_t _elem757; + xfer += iprot->readI64(_elem757); + this->aborted.insert(_elem757); } xfer += iprot->readSetEnd(); } @@ -18976,15 +19090,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size752; - ::apache::thrift::protocol::TType _etype755; - xfer += iprot->readSetBegin(_etype755, _size752); - uint32_t _i756; - for (_i756 = 0; _i756 < _size752; ++_i756) + uint32_t _size758; + ::apache::thrift::protocol::TType _etype761; + xfer += iprot->readSetBegin(_etype761, _size758); + uint32_t _i762; + for (_i762 = 0; _i762 < _size758; ++_i762) { - int64_t _elem757; - xfer += iprot->readI64(_elem757); - this->nosuch.insert(_elem757); + int64_t _elem763; + xfer += iprot->readI64(_elem763); + this->nosuch.insert(_elem763); } xfer += iprot->readSetEnd(); } @@ -19017,10 +19131,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 _iter758; - for (_iter758 = this->aborted.begin(); _iter758 != this->aborted.end(); ++_iter758) + std::set<int64_t> ::const_iterator _iter764; + for (_iter764 = this->aborted.begin(); _iter764 != this->aborted.end(); ++_iter764) { - xfer += oprot->writeI64((*_iter758)); + xfer += oprot->writeI64((*_iter764)); } xfer += oprot->writeSetEnd(); } @@ -19029,10 +19143,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 _iter759; - for (_iter759 = this->nosuch.begin(); _iter759 != this->nosuch.end(); ++_iter759) + std::set<int64_t> ::const_iterator _iter765; + for (_iter765 = this->nosuch.begin(); _iter765 != this->nosuch.end(); ++_iter765) { - xfer += oprot->writeI64((*_iter759)); + xfer += oprot->writeI64((*_iter765)); } xfer += oprot->writeSetEnd(); } @@ -19049,13 +19163,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other760) { - aborted = other760.aborted; - nosuch = other760.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other766) { + aborted = other766.aborted; + nosuch = other766.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other761) { - aborted = other761.aborted; - nosuch = other761.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other767) { + aborted = other767.aborted; + nosuch = other767.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -19148,9 +19262,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast762; - xfer += iprot->readI32(ecast762); - this->type = (CompactionType::type)ecast762; + int32_t ecast768; + xfer += iprot->readI32(ecast768); + this->type = (CompactionType::type)ecast768; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -19168,17 +19282,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size763; - ::apache::thrift::protocol::TType _ktype764; - ::apache::thrift::protocol::TType _vtype765; - xfer += iprot->readMapBegin(_ktype764, _vtype765, _size763); - uint32_t _i767; - for (_i767 = 0; _i767 < _size763; ++_i767) + uint32_t _size769; + ::apache::thrift::protocol::TType _ktype770; + ::apache::thrift::protocol::TType _vtype771; + xfer += iprot->readMapBegin(_ktype770, _vtype771, _size769); + uint32_t _i773; + for (_i773 = 0; _i773 < _size769; ++_i773) { - std::string _key768; - xfer += iprot->readString(_key768); - std::string& _val769 = this->properties[_key768]; - xfer += iprot->readString(_val769); + std::string _key774; + xfer += iprot->readString(_key774); + std::string& _val775 = this->properties[_key774]; + xfer += iprot->readString(_val775); } xfer += iprot->readMapEnd(); } @@ -19236,11 +19350,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 _iter770; - for (_iter770 = this->properties.begin(); _iter770 != this->properties.end(); ++_iter770) + std::map<std::string, std::string> ::const_iterator _iter776; + for (_iter776 = this->properties.begin(); _iter776 != this->properties.end(); ++_iter776) { - xfer += oprot->writeString(_iter770->first); - xfer += oprot->writeString(_iter770->second); + xfer += oprot->writeString(_iter776->first); + xfer += oprot->writeString(_iter776->second); } xfer += oprot->writeMapEnd(); } @@ -19262,23 +19376,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other771) { - dbname = other771.dbname; - tablename = other771.tablename; - partitionname = other771.partitionname; - type = other771.type; - runas = other771.runas; - properties = other771.properties; - __isset = other771.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other772) { - dbname = other772.dbname; - tablename = other772.tablename; - partitionname = other772.partitionname; - type = other772.type; - runas = other772.runas; - properties = other772.properties; - __isset = other772.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other777) { + dbname = other777.dbname; + tablename = other777.tablename; + partitionname = other777.partitionname; + type = other777.type; + runas = other777.runas; + properties = other777.properties; + __isset = other777.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other778) { + dbname = other778.dbname; + tablename = other778.tablename; + partitionname = other778.partitionname; + type = other778.type; + runas = other778.runas; + properties = other778.properties; + __isset = other778.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -19405,15 +19519,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other773) { - id = other773.id; - state = other773.state; - accepted = other773.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other779) { + id = other779.id; + state = other779.state; + accepted = other779.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other774) { - id = other774.id; - state = other774.state; - accepted = other774.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other780) { + id = other780.id; + state = other780.state; + accepted = other780.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -19474,11 +19588,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other775) { - (void) other775; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other781) { + (void) other781; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other776) { - (void) other776; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other782) { + (void) other782; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -19604,9 +19718,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast777; - xfer += iprot->readI32(ecast777); - this->type = (CompactionType::type)ecast777; + int32_t ecast783; + xfer += iprot->readI32(ecast783); + this->type = (CompactionType::type)ecast783; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -19793,37 +19907,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other778) { - dbname = other778.dbname; - tablename = other778.tablename; - partitionname = other778.partitionname; - type = other778.type; - state = other778.state; - workerid = other778.workerid; - start = other778.start; - runAs = other778.runAs; - hightestTxnId = other778.hightestTxnId; - metaInfo = other778.metaInfo; - endTime = other778.endTime; - hadoopJobId = other778.hadoopJobId; - id = other778.id; - __isset = other778.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other779) { - dbname = other779.dbname; - tablename = other779.tablename; - partitionname = other779.partitionname; - type = other779.type; - state = other779.state; - workerid = other779.workerid; - start = other779.start; - runAs = other779.runAs; - hightestTxnId = other779.hightestTxnId; - metaInfo = other779.metaInfo; - endTime = other779.endTime; - hadoopJobId = other779.hadoopJobId; - id = other779.id; - __isset = other779.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other784) { + dbname = other784.dbname; + tablename = other784.tablename; + partitionname = other784.partitionname; + type = other784.type; + state = other784.state; + workerid = other784.workerid; + start = other784.start; + runAs = other784.runAs; + hightestTxnId = other784.hightestTxnId; + metaInfo = other784.metaInfo; + endTime = other784.endTime; + hadoopJobId = other784.hadoopJobId; + id = other784.id; + __isset = other784.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other785) { + dbname = other785.dbname; + tablename = other785.tablename; + partitionname = other785.partitionname; + type = other785.type; + state = other785.state; + workerid = other785.workerid; + start = other785.start; + runAs = other785.runAs; + hightestTxnId = other785.hightestTxnId; + metaInfo = other785.metaInfo; + endTime = other785.endTime; + hadoopJobId = other785.hadoopJobId; + id = other785.id; + __isset = other785.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -19880,14 +19994,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size780; - ::apache::thrift::protocol::TType _etype783; - xfer += iprot->readListBegin(_etype783, _size780); - this->compacts.resize(_size780); - uint32_t _i784; - for (_i784 = 0; _i784 < _size780; ++_i784) + uint32_t _size786; + ::apache::thrift::protocol::TType _etype789; + xfer += iprot->readListBegin(_etype789, _size786); + this->compacts.resize(_size786); + uint32_t _i790; + for (_i790 = 0; _i790 < _size786; ++_i790) { - xfer += this->compacts[_i784].read(iprot); + xfer += this->compacts[_i790].read(iprot); } xfer += iprot->readListEnd(); } @@ -19918,10 +20032,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 _iter785; - for (_iter785 = this->compacts.begin(); _iter785 != this->compacts.end(); ++_iter785) + std::vector<ShowCompactResponseElement> ::const_iterator _iter791; + for (_iter791 = this->compacts.begin(); _iter791 != this->compacts.end(); ++_iter791) { - xfer += (*_iter785).write(oprot); + xfer += (*_iter791).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19937,11 +20051,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other786) { - compacts = other786.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other792) { + compacts = other792.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other787) { - compacts = other787.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other793) { + compacts = other793.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -20043,14 +20157,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size788; - ::apache::thrift::protocol::TType _etype791; - xfer += iprot->readListBegin(_etype791, _size788); - this->partitionnames.resize(_size788); - uint32_t _i792; - for (_i792 = 0; _i792 < _size788; ++_i792) + uint32_t _size794; + ::apache::thrift::protocol::TType _etype797; + xfer += iprot->readListBegin(_etype797, _size794); + this->partitionnames.resize(_size794); + uint32_t _i798; + for (_i798 = 0; _i798 < _size794; ++_i798) { - xfer += iprot->readString(this->partitionnames[_i792]); + xfer += iprot->readString(this->partitionnames[_i798]); } xfer += iprot->readListEnd(); } @@ -20061,9 +20175,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast793; - xfer += iprot->readI32(ecast793); - this->operationType = (DataOperationType::type)ecast793; + int32_t ecast799; + xfer += iprot->readI32(ecast799); + this->operationType = (DataOperationType::type)ecast799; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -20115,10 +20229,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionnames.size())); - std::vector<std::string> ::const_iterator _iter794; - for (_iter794 = this->partitionnames.begin(); _iter794 != this->partitionnames.end(); ++_iter794) + std::vector<std::string> ::const_iterator _iter800; + for (_iter800 = this->partitionnames.begin(); _iter800 != this->partitionnames.end(); ++_iter800) { - xfer += oprot->writeString((*_iter794)); + xfer += oprot->writeString((*_iter800)); } xfer += oprot->writeListEnd(); } @@ -20145,23 +20259,23 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other795) { - txnid = other795.txnid; - writeid = other795.writeid; - dbname = other795.dbname; - tablename = other795.tablename; - partitionnames = other795.partitionnames; - operationType = other795.operationType; - __isset = other795.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other796) { - txnid = other796.txnid; - writeid = other796.writeid; - dbname = other796.dbname; - tablename = other796.tablename; - partitionnames = other796.partitionnames; - operationType = other796.operationType; - __isset = other796.__isset; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other801) { + txnid = other801.txnid; + writeid = other801.writeid; + dbname = other801.dbname; + tablename = other801.tablename; + partitionnames = other801.partitionnames; + operationType = other801.operationType; + __isset = other801.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other802) { + txnid = other802.txnid; + writeid = other802.writeid; + dbname = other802.dbname; + tablename = other802.tablename; + partitionnames = other802.partitionnames; + operationType = other802.operationType; + __isset = other802.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -20344,23 +20458,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) { swap(a.__isset, b.__isset); } -BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other797) { - isnull = other797.isnull; - time = other797.time; - txnid = other797.txnid; - dbname = other797.dbname; - tablename = other797.tablename; - partitionname = other797.partitionname; - __isset = other797.__isset; -} -BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other798) { - isnull = other798.isnull; - time = other798.time; - txnid = other798.txnid; - dbname = other798.dbname; - tablename = other798.tablename; - partitionname = other798.partitionname; - __isset = other798.__isset; +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other803) { + isnull = other803.isnull; + time = other803.time; + txnid = other803.txnid; + dbname = other803.dbname; + tablename = other803.tablename; + partitionname = other803.partitionname; + __isset = other803.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other804) { + isnull = other804.isnull; + time = other804.time; + txnid = other804.txnid; + dbname = other804.dbname; + tablename = other804.tablename; + partitionname = other804.partitionname; + __isset = other804.__isset; return *this; } void BasicTxnInfo::printTo(std::ostream& out) const { @@ -20454,15 +20568,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size799; - ::apache::thrift::protocol::TType _etype802; - xfer += iprot->readSetBegin(_etype802, _size799); - uint32_t _i803; - for (_i803 = 0; _i803 < _size799; ++_i803) + uint32_t _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readSetBegin(_etype808, _size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) { - std::string _elem804; - xfer += iprot->readString(_elem804); - this->tablesUsed.insert(_elem804); + std::string _elem810; + xfer += iprot->readString(_elem810); + this->tablesUsed.insert(_elem810); } xfer += iprot->readSetEnd(); } @@ -20519,10 +20633,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 4); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tablesUsed.size())); - std::set<std::string> ::const_iterator _iter805; - for (_iter805 = this->tablesUsed.begin(); _iter805 != this->tablesUsed.end(); ++_iter805) + std::set<std::string> ::const_iterator _iter811; + for (_iter811 = this->tablesUsed.begin(); _iter811 != this->tablesUsed.end(); ++_iter811) { - xfer += oprot->writeString((*_iter805)); + xfer += oprot->writeString((*_iter811)); } xfer += oprot->writeSetEnd(); } @@ -20548,21 +20662,21 @@ void swap(CreationMetadata &a, CreationMetadata &b) { swap(a.__isset, b.__isset); } -CreationMetadata::CreationMetadata(const CreationMetadata& other806) { - catName = other806.catName; - dbName = other806.dbName; - tblName = other806.tblName; - tablesUsed = other806.tablesUsed; - validTxnList = other806.validTxnList; - __isset = other806.__isset; -} -CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other807) { - catName = other807.catName; - dbName = other807.dbName; - tblName = other807.tblName; - tablesUsed = other807.tablesUsed; - validTxnList = other807.validTxnList; - __isset = other807.__isset; +CreationMetadata::CreationMetadata(const CreationMetadata& other812) { + catName = other812.catName; + dbName = other812.dbName; + tblName = other812.tblName; + tablesUsed = other812.tablesUsed; + validTxnList = other812.validTxnList; + __isset = other812.__isset; +} +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other813) { + catName = other813.catName; + dbName = other813.dbName; + tblName = other813.tblName; + tablesUsed = other813.tablesUsed; + validTxnList = other813.validTxnList; + __isset = other813.__isset; return *this; } void CreationMetadata::printTo(std::ostream& out) const { @@ -20668,15 +20782,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other808) { - lastEvent = other808.lastEvent; - maxEvents = other808.maxEvents; - __isset = other808.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other814) { + lastEvent = other814.lastEvent; + maxEvents = other814.maxEvents; + __isset = other814.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other809) { - lastEvent = other809.lastEvent; - maxEvents = other809.maxEvents; - __isset = other809.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other815) { + lastEvent = other815.lastEvent; + maxEvents = other815.maxEvents; + __isset = other815.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -20896,27 +21010,27 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other810) { - eventId = other810.eventId; - eventTime = other810.eventTime; - eventType = other810.eventType; - dbName = other810.dbName; - tableName = other810.tableName; - message = other810.message; - messageFormat = other810.messageFormat; - catName = other810.catName; - __isset = other810.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other811) { - eventId = other811.eventId; - eventTime = other811.eventTime; - eventType = other811.eventType; - dbName = other811.dbName; - tableName = other811.tableName; - message = other811.message; - messageFormat = other811.messageFormat; - catName = other811.catName; - __isset = other811.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other816) { + eventId = other816.eventId; + eventTime = other816.eventTime; + eventType = other816.eventType; + dbName = other816.dbName; + tableName = other816.tableName; + message = other816.message; + messageFormat = other816.messageFormat; + catName = other816.catName; + __isset = other816.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other817) { + eventId = other817.eventId; + eventTime = other817.eventTime; + eventType = other817.eventType; + dbName = other817.dbName; + tableName = other817.tableName; + message = other817.message; + messageFormat = other817.messageFormat; + catName = other817.catName; + __isset = other817.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -20968,14 +21082,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size812; - ::apache::thrift::protocol::TType _etype815; - xfer += iprot->readListBegin(_etype815, _size812); - this->events.resize(_size812); - uint32_t _i816; - for (_i816 = 0; _i816 < _size812; ++_i816) + uint32_t _size818; + ::apache::thrift::protocol::TType _etype821; + xfer += iprot->readListBegin(_etype821, _size818); + this->events.resize(_size818); + uint32_t _i822; + for (_i822 = 0; _i822 < _size818; ++_i822) { - xfer += this->events[_i816].read(iprot); + xfer += this->events[_i822].read(iprot); } xfer += iprot->readListEnd(); } @@ -21006,10 +21120,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 _iter817; - for (_iter817 = this->events.begin(); _iter817 != this->events.end(); ++_iter817) + std::vector<NotificationEvent> ::const_iterator _iter823; + for (_iter823 = this->events.begin(); _iter823 != this->events.end(); ++_iter823) { - xfer += (*_iter817).write(oprot); + xfer += (*_iter823).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21025,11 +21139,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other818) { - events = other818.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other824) { + events = other824.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other819) { - events = other819.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other825) { + events = other825.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -21111,11 +21225,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other820) { - eventId = other820.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other826) { + eventId = other826.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other821) { - eventId = other821.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other827) { + eventId = other827.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -21237,17 +21351,17 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.__isset, b.__isset); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other822) { - fromEventId = other822.fromEventId; - dbName = other822.dbName; - catName = other822.catName; - __isset = other822.__isset; +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other828) { + fromEventId = other828.fromEventId; + dbName = other828.dbName; + catName = other828.catName; + __isset = other828.__isset; } -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other823) { - fromEventId = other823.fromEventId; - dbName = other823.dbName; - catName = other823.catName; - __isset = other823.__isset; +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other829) { + fromEventId = other829.fromEventId; + dbName = other829.dbName; + catName = other829.catName; + __isset = other829.__isset; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -21331,11 +21445,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other824) { - eventsCount = other824.eventsCount; +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other830) { + eventsCount = other830.eventsCount; } -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other825) { - eventsCount = other825.eventsCount; +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other831) { + eventsCount = other831.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -21398,14 +21512,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size826; - ::apache::thrift::protocol::TType _etype829; - xfer += iprot->readListBegin(_etype829, _size826); - this->filesAdded.resize(_size826); - uint32_t _i830; - for (_i830 = 0; _i830 < _size826; ++_i830) + uint32_t _size832; + ::apache::thrift::protocol::TType _etype835; + xfer += iprot->readListBegin(_etype835, _size832); + this->filesAdded.resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += iprot->readString(this->filesAdded[_i830]); + xfer += iprot->readString(this->filesAdded[_i836]); } xfer += iprot->readListEnd(); } @@ -21418,14 +21532,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size831; - ::apache::thrift::protocol::TType _etype834; - xfer += iprot->readListBegin(_etype834, _size831); - this->filesAddedChecksum.resize(_size831); - uint32_t _i835; - for (_i835 = 0; _i835 < _size831; ++_i835) + uint32_t _size837; + ::apache::thrift::protocol::TType _etype840; + xfer += iprot->readListBegin(_etype840, _size837); + this->filesAddedChecksum.resize(_size837); + uint32_t _i841; + for (_i841 = 0; _i841 < _size837; ++_i841) { - xfer += iprot->readString(this->filesAddedChecksum[_i835]); + xfer += iprot->readString(this->filesAddedChecksum[_i841]); } xfer += iprot->readListEnd(); } @@ -21461,10 +21575,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 _iter836; - for (_iter836 = this->filesAdded.begin(); _iter836 != this->filesAdded.end(); ++_iter836) + std::vector<std::string> ::const_iterator _iter842; + for (_iter842 = this->filesAdded.begin(); _iter842 != this->filesAdded.end(); ++_iter842) { - xfer += oprot->writeString((*_iter836)); + xfer += oprot->writeString((*_iter842)); } xfer += oprot->writeListEnd(); } @@ -21474,10 +21588,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 _iter837; - for (_iter837 = this->filesAddedChecksum.begin(); _iter837 != this->filesAddedChecksum.end(); ++_iter837) + std::vector<std::string> ::const_iterator _iter843; + for (_iter843 = this->filesAddedChecksum.begin(); _iter843 != this->filesAddedChecksum.end(); ++_iter843) { - xfer += oprot->writeString((*_iter837)); + xfer += oprot->writeString((*_iter843)); } xfer += oprot->writeListEnd(); } @@ -21496,17 +21610,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other838) { - replace = other838.replace; - filesAdded = other838.filesAdded; - filesAddedChecksum = other838.filesAddedChecksum; - __isset = other838.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other844) { + replace = other844.replace; + filesAdded = other844.filesAdded; + filesAddedChecksum = other844.filesAddedChecksum; + __isset = other844.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other839) { - replace = other839.replace; - filesAdded = other839.filesAdded; - filesAddedChecksum = other839.filesAddedChecksum; - __isset = other839.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other845) { + replace = other845.replace; + filesAdded = other845.filesAdded; + filesAddedChecksum = other845.filesAddedChecksum; + __isset = other845.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -21588,13 +21702,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other840) { - insertData = other840.insertData; - __isset = other840.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other846) { + insertData = other846.insertData; + __isset = other846.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other841) { - insertData = other841.insertData; - __isset = other841.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other847) { + insertData = other847.insertData; + __isset = other847.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -21696,14 +21810,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size842; - ::apache::thrift::protocol::TType _etype845; - xfer += iprot->readListBegin(_etype845, _size842); - this->partitionVals.resize(_size842); - uint32_t _i846; - for (_i846 = 0; _i846 < _size842; ++_i846) + uint32_t _size848; + ::apache::thrift::protocol::TType _etype851; + xfer += iprot->readListBegin(_etype851, _size848); + this->partitionVals.resize(_size848); + uint32_t _i852; + for (_i852 = 0; _i852 < _size848; ++_i852) { - xfer += iprot->readString(this->partitionVals[_i846]); + xfer += iprot->readString(this->partitionVals[_i852]); } xfer += iprot->readListEnd(); } @@ -21763,10 +21877,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionVals.size())); - std::vector<std::string> ::const_iterator _iter847; - for (_iter847 = this->partitionVals.begin(); _iter847 != this->partitionVals.end(); ++_iter847) + std::vector<std::string> ::const_iterator _iter853; + for (_iter853 = this->partitionVals.begin(); _iter853 != this->partitionVals.end(); ++_iter853) { - xfer += oprot->writeString((*_iter847)); + xfer += oprot->writeString((*_iter853)); } xfer += oprot->writeListEnd(); } @@ -21793,23 +21907,23 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other848) { - successful = other848.successful; - data = other848.data; - dbName = other848.dbName; - tableName = other848.tableName; - partitionVals = other848.partitionVals; - catName = other848.catName; - __isset = other848.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other849) { - successful = other849.successful; - data = other849.data; - dbName = other849.dbName; - tableName = other849.tableName; - partitionVals = other849.partitionVals; - catName = other849.catName; - __isset = other849.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other854) { + successful = other854.successful; + data = other854.data; + dbName = other854.dbName; + tableName = other854.tableName; + partitionVals = other854.partitionVals; + catName = other854.catName; + __isset = other854.__isset; +} +FireEventReque
<TRUNCATED>
