http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/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 8f04b9d..ef138e0 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 @@ -14308,6 +14308,808 @@ void CommitTxnRequest::printTo(std::ostream& out) const { } +GetValidWriteIdsRequest::~GetValidWriteIdsRequest() throw() { +} + + +void GetValidWriteIdsRequest::__set_fullTableNames(const std::vector<std::string> & val) { + this->fullTableNames = val; +} + +void GetValidWriteIdsRequest::__set_validTxnList(const std::string& val) { + this->validTxnList = val; +} + +uint32_t GetValidWriteIdsRequest::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_fullTableNames = false; + bool isset_validTxnList = 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->fullTableNames.clear(); + uint32_t _size617; + ::apache::thrift::protocol::TType _etype620; + xfer += iprot->readListBegin(_etype620, _size617); + this->fullTableNames.resize(_size617); + uint32_t _i621; + for (_i621 = 0; _i621 < _size617; ++_i621) + { + xfer += iprot->readString(this->fullTableNames[_i621]); + } + xfer += iprot->readListEnd(); + } + isset_fullTableNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->validTxnList); + isset_validTxnList = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fullTableNames) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_validTxnList) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetValidWriteIdsRequest"); + + 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 _iter622; + for (_iter622 = this->fullTableNames.begin(); _iter622 != this->fullTableNames.end(); ++_iter622) + { + xfer += oprot->writeString((*_iter622)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("validTxnList", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->validTxnList); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) { + using ::std::swap; + swap(a.fullTableNames, b.fullTableNames); + swap(a.validTxnList, b.validTxnList); +} + +GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other623) { + fullTableNames = other623.fullTableNames; + validTxnList = other623.validTxnList; +} +GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other624) { + fullTableNames = other624.fullTableNames; + validTxnList = other624.validTxnList; + return *this; +} +void GetValidWriteIdsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetValidWriteIdsRequest("; + out << "fullTableNames=" << to_string(fullTableNames); + out << ", " << "validTxnList=" << to_string(validTxnList); + out << ")"; +} + + +TableValidWriteIds::~TableValidWriteIds() throw() { +} + + +void TableValidWriteIds::__set_fullTableName(const std::string& val) { + this->fullTableName = val; +} + +void TableValidWriteIds::__set_writeIdHighWaterMark(const int64_t val) { + this->writeIdHighWaterMark = val; +} + +void TableValidWriteIds::__set_invalidWriteIds(const std::vector<int64_t> & val) { + this->invalidWriteIds = val; +} + +void TableValidWriteIds::__set_minOpenWriteId(const int64_t val) { + this->minOpenWriteId = val; +__isset.minOpenWriteId = true; +} + +void TableValidWriteIds::__set_abortedBits(const std::string& val) { + this->abortedBits = val; +} + +uint32_t TableValidWriteIds::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_fullTableName = false; + bool isset_writeIdHighWaterMark = false; + bool isset_invalidWriteIds = false; + bool isset_abortedBits = 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->fullTableName); + isset_fullTableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeIdHighWaterMark); + isset_writeIdHighWaterMark = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->invalidWriteIds.clear(); + uint32_t _size625; + ::apache::thrift::protocol::TType _etype628; + xfer += iprot->readListBegin(_etype628, _size625); + this->invalidWriteIds.resize(_size625); + uint32_t _i629; + for (_i629 = 0; _i629 < _size625; ++_i629) + { + xfer += iprot->readI64(this->invalidWriteIds[_i629]); + } + xfer += iprot->readListEnd(); + } + isset_invalidWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->minOpenWriteId); + this->__isset.minOpenWriteId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readBinary(this->abortedBits); + isset_abortedBits = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fullTableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeIdHighWaterMark) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_invalidWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_abortedBits) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TableValidWriteIds::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TableValidWriteIds"); + + xfer += oprot->writeFieldBegin("fullTableName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->fullTableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeIdHighWaterMark", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeIdHighWaterMark); + xfer += oprot->writeFieldEnd(); + + 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 _iter630; + for (_iter630 = this->invalidWriteIds.begin(); _iter630 != this->invalidWriteIds.end(); ++_iter630) + { + xfer += oprot->writeI64((*_iter630)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + if (this->__isset.minOpenWriteId) { + xfer += oprot->writeFieldBegin("minOpenWriteId", ::apache::thrift::protocol::T_I64, 4); + xfer += oprot->writeI64(this->minOpenWriteId); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("abortedBits", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeBinary(this->abortedBits); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TableValidWriteIds &a, TableValidWriteIds &b) { + using ::std::swap; + swap(a.fullTableName, b.fullTableName); + swap(a.writeIdHighWaterMark, b.writeIdHighWaterMark); + swap(a.invalidWriteIds, b.invalidWriteIds); + swap(a.minOpenWriteId, b.minOpenWriteId); + swap(a.abortedBits, b.abortedBits); + swap(a.__isset, b.__isset); +} + +TableValidWriteIds::TableValidWriteIds(const TableValidWriteIds& other631) { + fullTableName = other631.fullTableName; + writeIdHighWaterMark = other631.writeIdHighWaterMark; + invalidWriteIds = other631.invalidWriteIds; + minOpenWriteId = other631.minOpenWriteId; + abortedBits = other631.abortedBits; + __isset = other631.__isset; +} +TableValidWriteIds& TableValidWriteIds::operator=(const TableValidWriteIds& other632) { + fullTableName = other632.fullTableName; + writeIdHighWaterMark = other632.writeIdHighWaterMark; + invalidWriteIds = other632.invalidWriteIds; + minOpenWriteId = other632.minOpenWriteId; + abortedBits = other632.abortedBits; + __isset = other632.__isset; + return *this; +} +void TableValidWriteIds::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TableValidWriteIds("; + out << "fullTableName=" << to_string(fullTableName); + out << ", " << "writeIdHighWaterMark=" << to_string(writeIdHighWaterMark); + out << ", " << "invalidWriteIds=" << to_string(invalidWriteIds); + out << ", " << "minOpenWriteId="; (__isset.minOpenWriteId ? (out << to_string(minOpenWriteId)) : (out << "<null>")); + out << ", " << "abortedBits=" << to_string(abortedBits); + out << ")"; +} + + +GetValidWriteIdsResponse::~GetValidWriteIdsResponse() throw() { +} + + +void GetValidWriteIdsResponse::__set_tblValidWriteIds(const std::vector<TableValidWriteIds> & val) { + this->tblValidWriteIds = val; +} + +uint32_t GetValidWriteIdsResponse::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_tblValidWriteIds = 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->tblValidWriteIds.clear(); + uint32_t _size633; + ::apache::thrift::protocol::TType _etype636; + xfer += iprot->readListBegin(_etype636, _size633); + this->tblValidWriteIds.resize(_size633); + uint32_t _i637; + for (_i637 = 0; _i637 < _size633; ++_i637) + { + xfer += this->tblValidWriteIds[_i637].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_tblValidWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_tblValidWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t GetValidWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetValidWriteIdsResponse"); + + 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 _iter638; + for (_iter638 = this->tblValidWriteIds.begin(); _iter638 != this->tblValidWriteIds.end(); ++_iter638) + { + xfer += (*_iter638).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetValidWriteIdsResponse &a, GetValidWriteIdsResponse &b) { + using ::std::swap; + swap(a.tblValidWriteIds, b.tblValidWriteIds); +} + +GetValidWriteIdsResponse::GetValidWriteIdsResponse(const GetValidWriteIdsResponse& other639) { + tblValidWriteIds = other639.tblValidWriteIds; +} +GetValidWriteIdsResponse& GetValidWriteIdsResponse::operator=(const GetValidWriteIdsResponse& other640) { + tblValidWriteIds = other640.tblValidWriteIds; + return *this; +} +void GetValidWriteIdsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetValidWriteIdsResponse("; + out << "tblValidWriteIds=" << to_string(tblValidWriteIds); + out << ")"; +} + + +AllocateTableWriteIdsRequest::~AllocateTableWriteIdsRequest() throw() { +} + + +void AllocateTableWriteIdsRequest::__set_txnIds(const std::vector<int64_t> & val) { + this->txnIds = val; +} + +void AllocateTableWriteIdsRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +void AllocateTableWriteIdsRequest::__set_tableName(const std::string& val) { + this->tableName = val; +} + +uint32_t AllocateTableWriteIdsRequest::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_txnIds = false; + bool isset_dbName = false; + bool isset_tableName = 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->txnIds.clear(); + uint32_t _size641; + ::apache::thrift::protocol::TType _etype644; + xfer += iprot->readListBegin(_etype644, _size641); + this->txnIds.resize(_size641); + uint32_t _i645; + for (_i645 = 0; _i645 < _size641; ++_i645) + { + xfer += iprot->readI64(this->txnIds[_i645]); + } + xfer += iprot->readListEnd(); + } + isset_txnIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + isset_tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_tableName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllocateTableWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllocateTableWriteIdsRequest"); + + 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 _iter646; + for (_iter646 = this->txnIds.begin(); _iter646 != this->txnIds.end(); ++_iter646) + { + xfer += oprot->writeI64((*_iter646)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllocateTableWriteIdsRequest &a, AllocateTableWriteIdsRequest &b) { + using ::std::swap; + swap(a.txnIds, b.txnIds); + swap(a.dbName, b.dbName); + swap(a.tableName, b.tableName); +} + +AllocateTableWriteIdsRequest::AllocateTableWriteIdsRequest(const AllocateTableWriteIdsRequest& other647) { + txnIds = other647.txnIds; + dbName = other647.dbName; + tableName = other647.tableName; +} +AllocateTableWriteIdsRequest& AllocateTableWriteIdsRequest::operator=(const AllocateTableWriteIdsRequest& other648) { + txnIds = other648.txnIds; + dbName = other648.dbName; + tableName = other648.tableName; + return *this; +} +void AllocateTableWriteIdsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllocateTableWriteIdsRequest("; + out << "txnIds=" << to_string(txnIds); + out << ", " << "dbName=" << to_string(dbName); + out << ", " << "tableName=" << to_string(tableName); + out << ")"; +} + + +TxnToWriteId::~TxnToWriteId() throw() { +} + + +void TxnToWriteId::__set_txnId(const int64_t val) { + this->txnId = val; +} + +void TxnToWriteId::__set_writeId(const int64_t val) { + this->writeId = val; +} + +uint32_t TxnToWriteId::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_txnId = false; + bool isset_writeId = 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_I64) { + xfer += iprot->readI64(this->txnId); + isset_txnId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeId); + isset_writeId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeId) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t TxnToWriteId::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("TxnToWriteId"); + + xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->txnId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("writeId", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(TxnToWriteId &a, TxnToWriteId &b) { + using ::std::swap; + swap(a.txnId, b.txnId); + swap(a.writeId, b.writeId); +} + +TxnToWriteId::TxnToWriteId(const TxnToWriteId& other649) { + txnId = other649.txnId; + writeId = other649.writeId; +} +TxnToWriteId& TxnToWriteId::operator=(const TxnToWriteId& other650) { + txnId = other650.txnId; + writeId = other650.writeId; + return *this; +} +void TxnToWriteId::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "TxnToWriteId("; + out << "txnId=" << to_string(txnId); + out << ", " << "writeId=" << to_string(writeId); + out << ")"; +} + + +AllocateTableWriteIdsResponse::~AllocateTableWriteIdsResponse() throw() { +} + + +void AllocateTableWriteIdsResponse::__set_txnToWriteIds(const std::vector<TxnToWriteId> & val) { + this->txnToWriteIds = val; +} + +uint32_t AllocateTableWriteIdsResponse::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_txnToWriteIds = 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->txnToWriteIds.clear(); + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->txnToWriteIds.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) + { + xfer += this->txnToWriteIds[_i655].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_txnToWriteIds = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_txnToWriteIds) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AllocateTableWriteIdsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("AllocateTableWriteIdsResponse"); + + 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 _iter656; + for (_iter656 = this->txnToWriteIds.begin(); _iter656 != this->txnToWriteIds.end(); ++_iter656) + { + xfer += (*_iter656).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AllocateTableWriteIdsResponse &a, AllocateTableWriteIdsResponse &b) { + using ::std::swap; + swap(a.txnToWriteIds, b.txnToWriteIds); +} + +AllocateTableWriteIdsResponse::AllocateTableWriteIdsResponse(const AllocateTableWriteIdsResponse& other657) { + txnToWriteIds = other657.txnToWriteIds; +} +AllocateTableWriteIdsResponse& AllocateTableWriteIdsResponse::operator=(const AllocateTableWriteIdsResponse& other658) { + txnToWriteIds = other658.txnToWriteIds; + return *this; +} +void AllocateTableWriteIdsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "AllocateTableWriteIdsResponse("; + out << "txnToWriteIds=" << to_string(txnToWriteIds); + out << ")"; +} + + LockComponent::~LockComponent() throw() { } @@ -14375,9 +15177,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast617; - xfer += iprot->readI32(ecast617); - this->type = (LockType::type)ecast617; + int32_t ecast659; + xfer += iprot->readI32(ecast659); + this->type = (LockType::type)ecast659; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14385,9 +15187,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast618; - xfer += iprot->readI32(ecast618); - this->level = (LockLevel::type)ecast618; + int32_t ecast660; + xfer += iprot->readI32(ecast660); + this->level = (LockLevel::type)ecast660; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -14419,9 +15221,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast619; - xfer += iprot->readI32(ecast619); - this->operationType = (DataOperationType::type)ecast619; + int32_t ecast661; + xfer += iprot->readI32(ecast661); + this->operationType = (DataOperationType::type)ecast661; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -14521,27 +15323,27 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__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; +LockComponent::LockComponent(const LockComponent& other662) { + type = other662.type; + level = other662.level; + dbname = other662.dbname; + tablename = other662.tablename; + partitionname = other662.partitionname; + operationType = other662.operationType; + isAcid = other662.isAcid; + isDynamicPartitionWrite = other662.isDynamicPartitionWrite; + __isset = other662.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other663) { + type = other663.type; + level = other663.level; + dbname = other663.dbname; + tablename = other663.tablename; + partitionname = other663.partitionname; + operationType = other663.operationType; + isAcid = other663.isAcid; + isDynamicPartitionWrite = other663.isDynamicPartitionWrite; + __isset = other663.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -14613,14 +15415,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - 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) + uint32_t _size664; + ::apache::thrift::protocol::TType _etype667; + xfer += iprot->readListBegin(_etype667, _size664); + this->component.resize(_size664); + uint32_t _i668; + for (_i668 = 0; _i668 < _size664; ++_i668) { - xfer += this->component[_i626].read(iprot); + xfer += this->component[_i668].read(iprot); } xfer += iprot->readListEnd(); } @@ -14687,10 +15489,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 _iter627; - for (_iter627 = this->component.begin(); _iter627 != this->component.end(); ++_iter627) + std::vector<LockComponent> ::const_iterator _iter669; + for (_iter669 = this->component.begin(); _iter669 != this->component.end(); ++_iter669) { - xfer += (*_iter627).write(oprot); + xfer += (*_iter669).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14729,21 +15531,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__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; +LockRequest::LockRequest(const LockRequest& other670) { + component = other670.component; + txnid = other670.txnid; + user = other670.user; + hostname = other670.hostname; + agentInfo = other670.agentInfo; + __isset = other670.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other671) { + component = other671.component; + txnid = other671.txnid; + user = other671.user; + hostname = other671.hostname; + agentInfo = other671.agentInfo; + __isset = other671.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -14803,9 +15605,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast630; - xfer += iprot->readI32(ecast630); - this->state = (LockState::type)ecast630; + int32_t ecast672; + xfer += iprot->readI32(ecast672); + this->state = (LockState::type)ecast672; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -14851,13 +15653,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other631) { - lockid = other631.lockid; - state = other631.state; +LockResponse::LockResponse(const LockResponse& other673) { + lockid = other673.lockid; + state = other673.state; } -LockResponse& LockResponse::operator=(const LockResponse& other632) { - lockid = other632.lockid; - state = other632.state; +LockResponse& LockResponse::operator=(const LockResponse& other674) { + lockid = other674.lockid; + state = other674.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -14979,17 +15781,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other633) { - lockid = other633.lockid; - txnid = other633.txnid; - elapsed_ms = other633.elapsed_ms; - __isset = other633.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other675) { + lockid = other675.lockid; + txnid = other675.txnid; + elapsed_ms = other675.elapsed_ms; + __isset = other675.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other634) { - lockid = other634.lockid; - txnid = other634.txnid; - elapsed_ms = other634.elapsed_ms; - __isset = other634.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other676) { + lockid = other676.lockid; + txnid = other676.txnid; + elapsed_ms = other676.elapsed_ms; + __isset = other676.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -15073,11 +15875,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other635) { - lockid = other635.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other677) { + lockid = other677.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other636) { - lockid = other636.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other678) { + lockid = other678.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -15216,19 +16018,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other637) { - dbname = other637.dbname; - tablename = other637.tablename; - partname = other637.partname; - isExtended = other637.isExtended; - __isset = other637.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other679) { + dbname = other679.dbname; + tablename = other679.tablename; + partname = other679.partname; + isExtended = other679.isExtended; + __isset = other679.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other638) { - dbname = other638.dbname; - tablename = other638.tablename; - partname = other638.partname; - isExtended = other638.isExtended; - __isset = other638.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other680) { + dbname = other680.dbname; + tablename = other680.tablename; + partname = other680.partname; + isExtended = other680.isExtended; + __isset = other680.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -15381,9 +16183,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast639; - xfer += iprot->readI32(ecast639); - this->state = (LockState::type)ecast639; + int32_t ecast681; + xfer += iprot->readI32(ecast681); + this->state = (LockState::type)ecast681; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -15391,9 +16193,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast640; - xfer += iprot->readI32(ecast640); - this->type = (LockType::type)ecast640; + int32_t ecast682; + xfer += iprot->readI32(ecast682); + this->type = (LockType::type)ecast682; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15609,43 +16411,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__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; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other683) { + lockid = other683.lockid; + dbname = other683.dbname; + tablename = other683.tablename; + partname = other683.partname; + state = other683.state; + type = other683.type; + txnid = other683.txnid; + lastheartbeat = other683.lastheartbeat; + acquiredat = other683.acquiredat; + user = other683.user; + hostname = other683.hostname; + heartbeatCount = other683.heartbeatCount; + agentInfo = other683.agentInfo; + blockedByExtId = other683.blockedByExtId; + blockedByIntId = other683.blockedByIntId; + lockIdInternal = other683.lockIdInternal; + __isset = other683.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other684) { + lockid = other684.lockid; + dbname = other684.dbname; + tablename = other684.tablename; + partname = other684.partname; + state = other684.state; + type = other684.type; + txnid = other684.txnid; + lastheartbeat = other684.lastheartbeat; + acquiredat = other684.acquiredat; + user = other684.user; + hostname = other684.hostname; + heartbeatCount = other684.heartbeatCount; + agentInfo = other684.agentInfo; + blockedByExtId = other684.blockedByExtId; + blockedByIntId = other684.blockedByIntId; + lockIdInternal = other684.lockIdInternal; + __isset = other684.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -15704,14 +16506,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - 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) + uint32_t _size685; + ::apache::thrift::protocol::TType _etype688; + xfer += iprot->readListBegin(_etype688, _size685); + this->locks.resize(_size685); + uint32_t _i689; + for (_i689 = 0; _i689 < _size685; ++_i689) { - xfer += this->locks[_i647].read(iprot); + xfer += this->locks[_i689].read(iprot); } xfer += iprot->readListEnd(); } @@ -15740,10 +16542,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 _iter648; - for (_iter648 = this->locks.begin(); _iter648 != this->locks.end(); ++_iter648) + std::vector<ShowLocksResponseElement> ::const_iterator _iter690; + for (_iter690 = this->locks.begin(); _iter690 != this->locks.end(); ++_iter690) { - xfer += (*_iter648).write(oprot); + xfer += (*_iter690).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15760,13 +16562,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other649) { - locks = other649.locks; - __isset = other649.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other691) { + locks = other691.locks; + __isset = other691.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other650) { - locks = other650.locks; - __isset = other650.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other692) { + locks = other692.locks; + __isset = other692.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -15867,15 +16669,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other651) { - lockid = other651.lockid; - txnid = other651.txnid; - __isset = other651.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other693) { + lockid = other693.lockid; + txnid = other693.txnid; + __isset = other693.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other652) { - lockid = other652.lockid; - txnid = other652.txnid; - __isset = other652.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other694) { + lockid = other694.lockid; + txnid = other694.txnid; + __isset = other694.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -15978,13 +16780,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other653) { - min = other653.min; - max = other653.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other695) { + min = other695.min; + max = other695.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other654) { - min = other654.min; - max = other654.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other696) { + min = other696.min; + max = other696.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -16035,15 +16837,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size655; - ::apache::thrift::protocol::TType _etype658; - xfer += iprot->readSetBegin(_etype658, _size655); - uint32_t _i659; - for (_i659 = 0; _i659 < _size655; ++_i659) + uint32_t _size697; + ::apache::thrift::protocol::TType _etype700; + xfer += iprot->readSetBegin(_etype700, _size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - int64_t _elem660; - xfer += iprot->readI64(_elem660); - this->aborted.insert(_elem660); + int64_t _elem702; + xfer += iprot->readI64(_elem702); + this->aborted.insert(_elem702); } xfer += iprot->readSetEnd(); } @@ -16056,15 +16858,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size661; - ::apache::thrift::protocol::TType _etype664; - xfer += iprot->readSetBegin(_etype664, _size661); - uint32_t _i665; - for (_i665 = 0; _i665 < _size661; ++_i665) + uint32_t _size703; + ::apache::thrift::protocol::TType _etype706; + xfer += iprot->readSetBegin(_etype706, _size703); + uint32_t _i707; + for (_i707 = 0; _i707 < _size703; ++_i707) { - int64_t _elem666; - xfer += iprot->readI64(_elem666); - this->nosuch.insert(_elem666); + int64_t _elem708; + xfer += iprot->readI64(_elem708); + this->nosuch.insert(_elem708); } xfer += iprot->readSetEnd(); } @@ -16097,10 +16899,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 _iter667; - for (_iter667 = this->aborted.begin(); _iter667 != this->aborted.end(); ++_iter667) + std::set<int64_t> ::const_iterator _iter709; + for (_iter709 = this->aborted.begin(); _iter709 != this->aborted.end(); ++_iter709) { - xfer += oprot->writeI64((*_iter667)); + xfer += oprot->writeI64((*_iter709)); } xfer += oprot->writeSetEnd(); } @@ -16109,10 +16911,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 _iter668; - for (_iter668 = this->nosuch.begin(); _iter668 != this->nosuch.end(); ++_iter668) + std::set<int64_t> ::const_iterator _iter710; + for (_iter710 = this->nosuch.begin(); _iter710 != this->nosuch.end(); ++_iter710) { - xfer += oprot->writeI64((*_iter668)); + xfer += oprot->writeI64((*_iter710)); } xfer += oprot->writeSetEnd(); } @@ -16129,13 +16931,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other669) { - aborted = other669.aborted; - nosuch = other669.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other711) { + aborted = other711.aborted; + nosuch = other711.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other670) { - aborted = other670.aborted; - nosuch = other670.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other712) { + aborted = other712.aborted; + nosuch = other712.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -16228,9 +17030,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast671; - xfer += iprot->readI32(ecast671); - this->type = (CompactionType::type)ecast671; + int32_t ecast713; + xfer += iprot->readI32(ecast713); + this->type = (CompactionType::type)ecast713; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -16248,17 +17050,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - 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) + uint32_t _size714; + ::apache::thrift::protocol::TType _ktype715; + ::apache::thrift::protocol::TType _vtype716; + xfer += iprot->readMapBegin(_ktype715, _vtype716, _size714); + uint32_t _i718; + for (_i718 = 0; _i718 < _size714; ++_i718) { - std::string _key677; - xfer += iprot->readString(_key677); - std::string& _val678 = this->properties[_key677]; - xfer += iprot->readString(_val678); + std::string _key719; + xfer += iprot->readString(_key719); + std::string& _val720 = this->properties[_key719]; + xfer += iprot->readString(_val720); } xfer += iprot->readMapEnd(); } @@ -16316,11 +17118,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 _iter679; - for (_iter679 = this->properties.begin(); _iter679 != this->properties.end(); ++_iter679) + std::map<std::string, std::string> ::const_iterator _iter721; + for (_iter721 = this->properties.begin(); _iter721 != this->properties.end(); ++_iter721) { - xfer += oprot->writeString(_iter679->first); - xfer += oprot->writeString(_iter679->second); + xfer += oprot->writeString(_iter721->first); + xfer += oprot->writeString(_iter721->second); } xfer += oprot->writeMapEnd(); } @@ -16342,23 +17144,23 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__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; +CompactionRequest::CompactionRequest(const CompactionRequest& other722) { + dbname = other722.dbname; + tablename = other722.tablename; + partitionname = other722.partitionname; + type = other722.type; + runas = other722.runas; + properties = other722.properties; + __isset = other722.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other723) { + dbname = other723.dbname; + tablename = other723.tablename; + partitionname = other723.partitionname; + type = other723.type; + runas = other723.runas; + properties = other723.properties; + __isset = other723.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -16485,15 +17287,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other682) { - id = other682.id; - state = other682.state; - accepted = other682.accepted; +CompactionResponse::CompactionResponse(const CompactionResponse& other724) { + id = other724.id; + state = other724.state; + accepted = other724.accepted; } -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other683) { - id = other683.id; - state = other683.state; - accepted = other683.accepted; +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other725) { + id = other725.id; + state = other725.state; + accepted = other725.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -16554,11 +17356,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other684) { - (void) other684; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other726) { + (void) other726; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other685) { - (void) other685; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other727) { + (void) other727; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -16684,9 +17486,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast686; - xfer += iprot->readI32(ecast686); - this->type = (CompactionType::type)ecast686; + int32_t ecast728; + xfer += iprot->readI32(ecast728); + this->type = (CompactionType::type)ecast728; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -16873,37 +17675,37 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__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; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other729) { + dbname = other729.dbname; + tablename = other729.tablename; + partitionname = other729.partitionname; + type = other729.type; + state = other729.state; + workerid = other729.workerid; + start = other729.start; + runAs = other729.runAs; + hightestTxnId = other729.hightestTxnId; + metaInfo = other729.metaInfo; + endTime = other729.endTime; + hadoopJobId = other729.hadoopJobId; + id = other729.id; + __isset = other729.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other730) { + dbname = other730.dbname; + tablename = other730.tablename; + partitionname = other730.partitionname; + type = other730.type; + state = other730.state; + workerid = other730.workerid; + start = other730.start; + runAs = other730.runAs; + hightestTxnId = other730.hightestTxnId; + metaInfo = other730.metaInfo; + endTime = other730.endTime; + hadoopJobId = other730.hadoopJobId; + id = other730.id; + __isset = other730.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -16960,14 +17762,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - 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) + uint32_t _size731; + ::apache::thrift::protocol::TType _etype734; + xfer += iprot->readListBegin(_etype734, _size731); + this->compacts.resize(_size731); + uint32_t _i735; + for (_i735 = 0; _i735 < _size731; ++_i735) { - xfer += this->compacts[_i693].read(iprot); + xfer += this->compacts[_i735].read(iprot); } xfer += iprot->readListEnd(); } @@ -16998,10 +17800,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 _iter694; - for (_iter694 = this->compacts.begin(); _iter694 != this->compacts.end(); ++_iter694) + std::vector<ShowCompactResponseElement> ::const_iterator _iter736; + for (_iter736 = this->compacts.begin(); _iter736 != this->compacts.end(); ++_iter736) { - xfer += (*_iter694).write(oprot); + xfer += (*_iter736).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17017,11 +17819,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other695) { - compacts = other695.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other737) { + compacts = other737.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other696) { - compacts = other696.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other738) { + compacts = other738.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -17040,6 +17842,10 @@ void AddDynamicPartitions::__set_txnid(const int64_t val) { this->txnid = val; } +void AddDynamicPartitions::__set_writeid(const int64_t val) { + this->writeid = val; +} + void AddDynamicPartitions::__set_dbname(const std::string& val) { this->dbname = val; } @@ -17070,6 +17876,7 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot using ::apache::thrift::protocol::TProtocolException; bool isset_txnid = false; + bool isset_writeid = false; bool isset_dbname = false; bool isset_tablename = false; bool isset_partitionnames = false; @@ -17091,6 +17898,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot } break; case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->writeid); + isset_writeid = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->dbname); isset_dbname = true; @@ -17098,7 +17913,7 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 3: + case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->tablename); isset_tablename = true; @@ -17106,18 +17921,18 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 4: + case 5: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - 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) + uint32_t _size739; + ::apache::thrift::protocol::TType _etype742; + xfer += iprot->readListBegin(_etype742, _size739); + this->partitionnames.resize(_size739); + uint32_t _i743; + for (_i743 = 0; _i743 < _size739; ++_i743) { - xfer += iprot->readString(this->partitionnames[_i701]); + xfer += iprot->readString(this->partitionnames[_i743]); } xfer += iprot->readListEnd(); } @@ -17126,11 +17941,11 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 5: + case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast702; - xfer += iprot->readI32(ecast702); - this->operationType = (DataOperationType::type)ecast702; + int32_t ecast744; + xfer += iprot->readI32(ecast744); + this->operationType = (DataOperationType::type)ecast744; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -17147,6 +17962,8 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (!isset_txnid) throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_writeid) + throw TProtocolException(TProtocolException::INVALID_DATA); if (!isset_dbname) throw TProtocolException(TProtocolException::INVALID_DATA); if (!isset_tablename) @@ -17165,28 +17982,32 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeI64(this->txnid); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("writeid", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->writeid); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 3); xfer += oprot->writeString(this->dbname); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeFieldBegin("tablename", ::apache::thrift::protocol::T_STRING, 4); xfer += oprot->writeString(this->tablename); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); + 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 _iter703; - for (_iter703 = this->partitionnames.begin(); _iter703 != this->partitionnames.end(); ++_iter703) + std::vector<std::string> ::const_iterator _iter745; + for (_iter745 = this->partitionnames.begin(); _iter745 != this->partitionnames.end(); ++_iter745) { - xfer += oprot->writeString((*_iter703)); + xfer += oprot->writeString((*_iter745)); } xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); if (this->__isset.operationType) { - xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 5); + xfer += oprot->writeFieldBegin("operationType", ::apache::thrift::protocol::T_I32, 6); xfer += oprot->writeI32((int32_t)this->operationType); xfer += oprot->writeFieldEnd(); } @@ -17198,6 +18019,7 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { using ::std::swap; swap(a.txnid, b.txnid); + swap(a.writeid, b.writeid); swap(a.dbname, b.dbname); swap(a.tablename, b.tablename); swap(a.partitionnames, b.partitionnames); @@ -17205,27 +18027,30 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__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; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other746) { + txnid = other746.txnid; + writeid = other746.writeid; + dbname = other746.dbname; + tablename = other746.tablename; + partitionnames = other746.partitionnames; + operationType = other746.operationType; + __isset = other746.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other747) { + txnid = other747.txnid; + writeid = other747.writeid; + dbname = other747.dbname; + tablename = other747.tablename; + partitionnames = other747.partitionnames; + operationType = other747.operationType; + __isset = other747.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "AddDynamicPartitions("; out << "txnid=" << to_string(txnid); + out << ", " << "writeid=" << to_string(writeid); out << ", " << "dbname=" << to_string(dbname); out << ", " << "tablename=" << to_string(tablename); out << ", " << "partitionnames=" << to_string(partitionnames); @@ -17401,23 +18226,23 @@ void swap(BasicTxnInfo &a, BasicTxnInfo &b) { swap(a.__isset, b.__isset); } -BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other706) { - isnull = other706.isnull; - time = other706.time; - txnid = other706.txnid; - dbname = other706.dbname; - tablename = other706.tablename; - partitionname = other706.partitionname; - __isset = other706.__isset; -} -BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other707) { - isnull = other707.isnull; - time = other707.time; - txnid = other707.txnid; - dbname = other707.dbname; - tablename = other707.tablename; - partitionname = other707.partitionname; - __isset = other707.__isset; +BasicTxnInfo::BasicTxnInfo(const BasicTxnInfo& other748) { + isnull = other748.isnull; + time = other748.time; + txnid = other748.txnid; + dbname = other748.dbname; + tablename = other748.tablename; + partitionname = other748.partitionname; + __isset = other748.__isset; +} +BasicTxnInfo& BasicTxnInfo::operator=(const BasicTxnInfo& other749) { + isnull = other749.isnull; + time = other749.time; + txnid = other749.txnid; + dbname = other749.dbname; + tablename = other749.tablename; + partitionname = other749.partitionname; + __isset = other749.__isset; return *this; } void BasicTxnInfo::printTo(std::ostream& out) const { @@ -17498,15 +18323,15 @@ uint32_t CreationMetadata::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->tablesUsed.clear(); - uint32_t _size708; - ::apache::thrift::protocol::TType _etype711; - xfer += iprot->readSetBegin(_etype711, _size708); - uint32_t _i712; - for (_i712 = 0; _i712 < _size708; ++_i712) + uint32_t _size750; + ::apache::thrift::protocol::TType _etype753; + xfer += iprot->readSetBegin(_etype753, _size750); + uint32_t _i754; + for (_i754 = 0; _i754 < _size750; ++_i754) { - std::string _elem713; - xfer += iprot->readString(_elem713); - this->tablesUsed.insert(_elem713); + std::string _elem755; + xfer += iprot->readString(_elem755); + this->tablesUsed.insert(_elem755); } xfer += iprot->readSetEnd(); } @@ -17557,10 +18382,10 @@ uint32_t CreationMetadata::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tablesUsed", ::apache::thrift::protocol::T_SET, 3); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tablesUsed.size())); - std::set<std::string> ::const_iterator _iter714; - for (_iter714 = this->tablesUsed.begin(); _iter714 != this->tablesUsed.end(); ++_iter714) + std::set<std::string> ::const_iterator _iter756; + for (_iter756 = this->tablesUsed.begin(); _iter756 != this->tablesUsed.end(); ++_iter756) { - xfer += oprot->writeString((*_iter714)); + xfer += oprot->writeString((*_iter756)); } xfer += oprot->writeSetEnd(); } @@ -17585,19 +18410,19 @@ void swap(CreationMetadata &a, CreationMetadata &b) { swap(a.__isset, b.__isset); } -CreationMetadata::CreationMetadata(const CreationMetadata& other715) { - dbName = other715.dbName; - tblName = other715.tblName; - tablesUsed = other715.tablesUsed; - validTxnList = other715.validTxnList; - __isset = other715.__isset; +CreationMetadata::CreationMetadata(const CreationMetadata& other757) { + dbName = other757.dbName; + tblName = other757.tblName; + tablesUsed = other757.tablesUsed; + validTxnList = other757.validTxnList; + __isset = other757.__isset; } -CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other716) { - dbName = other716.dbName; - tblName = other716.tblName; - tablesUsed = other716.tablesUsed; - validTxnList = other716.validTxnList; - __isset = other716.__isset; +CreationMetadata& CreationMetadata::operator=(const CreationMetadata& other758) { + dbName = other758.dbName; + tblName = other758.tblName; + tablesUsed = other758.tablesUsed; + validTxnList = other758.validTxnList; + __isset = other758.__isset; return *this; } void CreationMetadata::printTo(std::ostream& out) const { @@ -17702,15 +18527,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other717) { - lastEvent = other717.lastEvent; - maxEvents = other717.maxEvents; - __isset = other717.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other759) { + lastEvent = other759.lastEvent; + maxEvents = other759.maxEvents; + __isset = other759.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other718) { - lastEvent = other718.lastEvent; - maxEvents = other718.maxEvents; - __isset = other718.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other760) { + lastEvent = other760.lastEvent; + maxEvents = other760.maxEvents; + __isset = other760.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -17911,25 +18736,25 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other719) { - eventId = other719.eventId; - eventTime = other719.eventTime; - eventType = other719.eventType; - dbName = other719.dbName; - tableName = other719.tableName; - message = other719.message; - messageFormat = other719.messageFormat; - __isset = other719.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other720) { - eventId = other720.eventId; - eventTime = other720.eventTime; - eventType = other720.eventType; - dbName = other720.dbName; - tableName = other720.tableName; - message = other720.message; - messageFormat = other720.messageFormat; - __isset = other720.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other761) { + eventId = other761.eventId; + eventTime = other761.eventTime; + eventType = other761.eventType; + dbName = other761.dbName; + tableName = other761.tableName; + message = other761.message; + messageFormat = other761.messageFormat; + __isset = other761.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other762) { + eventId = other762.eventId; + eventTime = other762.eventTime; + eventType = other762.eventType; + dbName = other762.dbName; + tableName = other762.tableName; + message = other762.message; + messageFormat = other762.messageFormat; + __isset = other762.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -17980,14 +18805,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size721; - ::apache::thrift::protocol::TType _etype724; - xfer += iprot->readListBegin(_etype724, _size721); - this->events.resize(_size721); - uint32_t _i725; - for (_i725 = 0; _i725 < _size721; ++_i725) + uint32_t _size763; + ::apache::thrift::protocol::TType _etype766; + xfer += iprot->readListBegin(_etype766, _size763); + this->events.resize(_size763); + uint32_t _i767; + for (_i767 = 0; _i767 < _size763; ++_i767) { - xfer += this->events[_i725].read(iprot); + xfer += this->events[_i767].read(iprot); } xfer += iprot->readListEnd(); } @@ -18018,10 +18843,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 _iter726; - for (_iter726 = this->events.begin(); _iter726 != this->events.end(); ++_iter726) + std::vector<NotificationEvent> ::const_iterator _iter768; + for (_iter768 = this->events.begin(); _iter768 != this->events.end(); ++_iter768) { - xfer += (*_iter726).write(oprot); + xfer += (*_iter768).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18037,11 +18862,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other727) { - events = other727.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other769) { + events = other769.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other728) { - events = other728.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other770) { + events = other770.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -18123,11 +18948,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other729) { - eventId = other729.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other771) { + eventId = other771.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other730) { - eventId = other730.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other772) { + eventId = other772.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -18229,13 +19054,13 @@ void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) swap(a.dbName, b.dbName); } -NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other731) { - fromEventId = other731.fromEventId; - dbName = other731.dbName; +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other773) { + fromEventId = other773.fromEventId; + dbName = other773.dbName; } -NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other732) { - fromEventId = other732.fromEventId; - dbName = other732.dbName; +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other774) { + fromEventId = other774.fromEventId; + dbName = other774.dbName; return *this; } void NotificationEventsCountRequest::printTo(std::ostream& out) const { @@ -18318,11 +19143,11 @@ void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b swap(a.eventsCount, b.eventsCount); } -NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other733) { - eventsCount = other733.eventsCount; +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other775) { + eventsCount = other775.eventsCount; } -NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other734) { - eventsCount = other734.eventsCount; +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other776) { + eventsCount = other776.eventsCount; return *this; } void NotificationEventsCountResponse::printTo(std::ostream& out) const { @@ -18385,14 +19210,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size735; - ::apache::thrift::protocol::TType _etype738; - xfer += iprot->readListBegin(_etype738, _size735); - this->filesAdded.resize(_size735); - uint32_t _i739; - for (_i739 = 0; _i739 < _size735; ++_i739) + uint32_t _size777; + ::apache::thrift::protocol::TType _etype780; + xfer += iprot->readListBegin(_etype780, _size777); + this->filesAdded.resize(_size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - xfer += iprot->readString(this->filesAdded[_i739]); + xfer += iprot->readString(this->filesAdded[_i781]); } xfer += iprot->readListEnd(); } @@ -18405,14 +19230,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size740; - ::apache::thrift::protocol::TType _etype743; - xfer += iprot->readListBegin(_etype743, _size740); - this->filesAddedChecksum.resize(_size740); - uint32_t _i744; - for (_i744 = 0; _i744 < _size740; ++_i744) + uint32_t _size782; + ::apache::thrift::protocol::TType _etype785; + xfer += iprot->readListBegin(_etype785, _size782); + this->filesAddedChecksum.resize(_size782); + uint32_t _i786; + for (_i786 = 0; _i786 < _size782; ++_i786) { - xfer += iprot->readString(this->filesAddedChecksum[_i744]); + xfer += iprot->readString(this->filesAddedChecksum[_i786]); } xfer += iprot->readListEnd(); } @@ -18448,10 +19273,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 _iter745; - for (_iter745 = this->filesAdded.begin(); _iter745 != this->filesAdded.end(); ++_iter745) + std::vector<std::string> ::const_iterator _iter787; + for (_iter787 = this->filesAdded.begin(); _iter787 != this->filesAdded.end(); ++_iter787) { - xfer += oprot->writeString((*_iter745)); + xfer += oprot->writeString((*_iter787)); } xfer += oprot->writeListEnd(); } @@ -18461,10 +19286,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 _iter746; - for (_iter746 = this->filesAddedChecksum.begin(); _iter746 != this->filesAddedChecksum.end(); ++_iter746) + std::vector<std::string> ::const_iterator _iter788; + for (_iter788 = this->filesAddedChecksum.begin(); _iter788 != this->filesAddedChecksum.end(); ++_iter788) { - xfer += oprot->writeString((*_iter746)); + xfer += oprot->writeString((*_iter788)); } xfer += oprot->writeListEnd(); } @@ -18483,17 +19308,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other747) { - replace = other747.replace; - filesAdded = other747.filesAdded; - filesAddedChecksum = other747.filesAddedChecksum; - __isset = other747.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other789) { + replace = other789.replace; + filesAdded = other789.filesAdded; + filesAddedChecksum = other789.filesAddedChecksum; + __isset = other789.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other748) { - replace = other748.replace; - filesAdded = other748.filesAdded; - filesAddedChecksum = other748.filesAddedChecksum; - __isset = other748.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other790) { + replace = other790.replace; + filesAdded = other790.filesAdded; + filesAddedChecksum = other790.filesAddedChecksum; + __isset = other790.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -18575,13 +19400,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other749) { - insertData = other749.insertData; - __isset = other749.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other791) { + insertData = other791.insertData; + __isset = other791.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other750) { - insertData = other750.insertData; - __isset = other750.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other792) { + insertData = other792.insertData; + __isset = other792.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -18678,14 +19503,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size751; - ::apache::thrift::protocol::TType _etype754; - xfer += iprot->readListBegin(_etype754, _size751); - this->partitionVals.resize(_size751); - uint32_t _i755; - for (_i755 = 0; _i755 < _size751; ++_i755) + uint32_t _size793; + ::apache::thrift::protocol::TType _etype796; + xfer += iprot->readListBegin(_etype796, _size793); + this->partitionVals.resize(_size793); + uint32_t _i797; + for (_i797 = 0; _i797 < _size793; ++_i797) { - xfer += iprot->readString(this->partitionVals[_i755]); + xfer += iprot->readString(this->partitionVals[_i797]); } xfer += iprot->readListEnd(); } @@ -18737,10 +19562,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 _iter756; - for (_iter756 = this->partitionVals.begin(); _iter756 != this->partitionVals.end(); ++_iter756) + std::vector<std::string> ::const_iterator _iter798; + for (_iter798 = this->partitionVals.begin(); _iter798 != this->partitionVals.end(); ++_iter798) { - xfer += oprot->writeString((*_iter756)); + xfer += oprot->writeString((*_iter798)); } xfer += oprot->writeListEnd(); } @@ -18761,21 +19586,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other757) { - successful = other757.successful; - data = other757.data; - dbName = other757.dbName; - tableName = other757.tableName; - partitionVals = other757.partitionVals; - __isset = other757.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other758) { - successful = other758.successful; - data = other758.data; - dbName = other758.dbName; - tableName = other758.tableName; - partitionVals = other758.partitionVals; - __isset = other758.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other799) { + successful = other799.successful; + data = other799.data; + dbName = other799.dbName; + tableName = other799.tableName; + partitionVals = other799.partitionVals; + __isset = other799.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other800) { + successful = other800.successful; + data = other800.data; + dbName = other800.dbName; + tableName = other800.tableName; + partitionVals = other800.partitionVals; + __isset = other800.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -18838,11 +19663,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other759) { - (void) other759; +FireEventResponse::FireEventResponse(const FireEventResponse& other801) { + (void) other801; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other760) { - (void) other760; +FireEventResponse& Fire
<TRUNCATED>
