Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id A307E200CA3 for ; Tue, 2 May 2017 22:53:54 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id A18B5160BAB; Tue, 2 May 2017 20:53:54 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 552C9160BBE for ; Tue, 2 May 2017 22:53:52 +0200 (CEST) Received: (qmail 19306 invoked by uid 500); 2 May 2017 20:53:51 -0000 Mailing-List: contact commits-help@hive.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: hive-dev@hive.apache.org Delivered-To: mailing list commits@hive.apache.org Received: (qmail 18838 invoked by uid 99); 2 May 2017 20:53:49 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 02 May 2017 20:53:49 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 9DDD9E0667; Tue, 2 May 2017 20:53:49 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: weiz@apache.org To: commits@hive.apache.org Date: Tue, 02 May 2017 20:53:52 -0000 Message-Id: <09dc3a1bd90e4941affcf00b1bc3bd77@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [4/6] hive git commit: HIVE-16534 : Add capability to tell aborted transactions apart from open transactions in ValidTxnList (Wei Zheng, reviewed by Eugene Koifman) archived-at: Tue, 02 May 2017 20:53:54 -0000 http://git-wip-us.apache.org/repos/asf/hive/blob/6af51245/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index b38e1cb..e3725a5 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -11981,7 +11981,7 @@ void GetOpenTxnsResponse::__set_txn_high_water_mark(const int64_t val) { this->txn_high_water_mark = val; } -void GetOpenTxnsResponse::__set_open_txns(const std::set & val) { +void GetOpenTxnsResponse::__set_open_txns(const std::vector & val) { this->open_txns = val; } @@ -11990,6 +11990,10 @@ void GetOpenTxnsResponse::__set_min_open_txn(const int64_t val) { __isset.min_open_txn = true; } +void GetOpenTxnsResponse::__set_abortedBits(const std::string& val) { + this->abortedBits = val; +} + uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -12004,6 +12008,7 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) bool isset_txn_high_water_mark = false; bool isset_open_txns = false; + bool isset_abortedBits = false; while (true) { @@ -12022,20 +12027,19 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) } break; case 2: - if (ftype == ::apache::thrift::protocol::T_SET) { + if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); uint32_t _size517; ::apache::thrift::protocol::TType _etype520; - xfer += iprot->readSetBegin(_etype520, _size517); + xfer += iprot->readListBegin(_etype520, _size517); + this->open_txns.resize(_size517); uint32_t _i521; for (_i521 = 0; _i521 < _size517; ++_i521) { - int64_t _elem522; - xfer += iprot->readI64(_elem522); - this->open_txns.insert(_elem522); + xfer += iprot->readI64(this->open_txns[_i521]); } - xfer += iprot->readSetEnd(); + xfer += iprot->readListEnd(); } isset_open_txns = true; } else { @@ -12050,6 +12054,14 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; + case 4: + 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; @@ -12063,6 +12075,8 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) throw TProtocolException(TProtocolException::INVALID_DATA); if (!isset_open_txns) throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_abortedBits) + throw TProtocolException(TProtocolException::INVALID_DATA); return xfer; } @@ -12075,15 +12089,15 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeI64(this->txn_high_water_mark); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); + xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { - xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::set ::const_iterator _iter523; - for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); + std::vector ::const_iterator _iter522; + for (_iter522 = this->open_txns.begin(); _iter522 != this->open_txns.end(); ++_iter522) { - xfer += oprot->writeI64((*_iter523)); + xfer += oprot->writeI64((*_iter522)); } - xfer += oprot->writeSetEnd(); + xfer += oprot->writeListEnd(); } xfer += oprot->writeFieldEnd(); @@ -12092,6 +12106,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeI64(this->min_open_txn); xfer += oprot->writeFieldEnd(); } + xfer += oprot->writeFieldBegin("abortedBits", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeBinary(this->abortedBits); + xfer += oprot->writeFieldEnd(); + xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -12102,20 +12120,23 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.txn_high_water_mark, b.txn_high_water_mark); swap(a.open_txns, b.open_txns); swap(a.min_open_txn, b.min_open_txn); + swap(a.abortedBits, b.abortedBits); swap(a.__isset, b.__isset); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other524) { +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other523) { + txn_high_water_mark = other523.txn_high_water_mark; + open_txns = other523.open_txns; + min_open_txn = other523.min_open_txn; + abortedBits = other523.abortedBits; + __isset = other523.__isset; +} +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other524) { txn_high_water_mark = other524.txn_high_water_mark; open_txns = other524.open_txns; min_open_txn = other524.min_open_txn; + abortedBits = other524.abortedBits; __isset = other524.__isset; -} -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other525) { - txn_high_water_mark = other525.txn_high_water_mark; - open_txns = other525.open_txns; - min_open_txn = other525.min_open_txn; - __isset = other525.__isset; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -12124,6 +12145,7 @@ void GetOpenTxnsResponse::printTo(std::ostream& out) const { out << "txn_high_water_mark=" << to_string(txn_high_water_mark); out << ", " << "open_txns=" << to_string(open_txns); out << ", " << "min_open_txn="; (__isset.min_open_txn ? (out << to_string(min_open_txn)) : (out << "")); + out << ", " << "abortedBits=" << to_string(abortedBits); out << ")"; } @@ -12259,19 +12281,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other526) { +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other525) { + num_txns = other525.num_txns; + user = other525.user; + hostname = other525.hostname; + agentInfo = other525.agentInfo; + __isset = other525.__isset; +} +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other526) { num_txns = other526.num_txns; user = other526.user; hostname = other526.hostname; agentInfo = other526.agentInfo; __isset = other526.__isset; -} -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other527) { - num_txns = other527.num_txns; - user = other527.user; - hostname = other527.hostname; - agentInfo = other527.agentInfo; - __isset = other527.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -12319,14 +12341,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size528; - ::apache::thrift::protocol::TType _etype531; - xfer += iprot->readListBegin(_etype531, _size528); - this->txn_ids.resize(_size528); - uint32_t _i532; - for (_i532 = 0; _i532 < _size528; ++_i532) + uint32_t _size527; + ::apache::thrift::protocol::TType _etype530; + xfer += iprot->readListBegin(_etype530, _size527); + this->txn_ids.resize(_size527); + uint32_t _i531; + for (_i531 = 0; _i531 < _size527; ++_i531) { - xfer += iprot->readI64(this->txn_ids[_i532]); + xfer += iprot->readI64(this->txn_ids[_i531]); } xfer += iprot->readListEnd(); } @@ -12357,10 +12379,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(this->txn_ids.size())); - std::vector ::const_iterator _iter533; - for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533) + std::vector ::const_iterator _iter532; + for (_iter532 = this->txn_ids.begin(); _iter532 != this->txn_ids.end(); ++_iter532) { - xfer += oprot->writeI64((*_iter533)); + xfer += oprot->writeI64((*_iter532)); } xfer += oprot->writeListEnd(); } @@ -12376,11 +12398,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) { - txn_ids = other534.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other533) { + txn_ids = other533.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) { - txn_ids = other535.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other534) { + txn_ids = other534.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -12462,11 +12484,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) { - txnid = other536.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other535) { + txnid = other535.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) { - txnid = other537.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other536) { + txnid = other536.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12511,14 +12533,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size538; - ::apache::thrift::protocol::TType _etype541; - xfer += iprot->readListBegin(_etype541, _size538); - this->txn_ids.resize(_size538); - uint32_t _i542; - for (_i542 = 0; _i542 < _size538; ++_i542) + uint32_t _size537; + ::apache::thrift::protocol::TType _etype540; + xfer += iprot->readListBegin(_etype540, _size537); + this->txn_ids.resize(_size537); + uint32_t _i541; + for (_i541 = 0; _i541 < _size537; ++_i541) { - xfer += iprot->readI64(this->txn_ids[_i542]); + xfer += iprot->readI64(this->txn_ids[_i541]); } xfer += iprot->readListEnd(); } @@ -12549,10 +12571,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(this->txn_ids.size())); - std::vector ::const_iterator _iter543; - for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543) + std::vector ::const_iterator _iter542; + for (_iter542 = this->txn_ids.begin(); _iter542 != this->txn_ids.end(); ++_iter542) { - xfer += oprot->writeI64((*_iter543)); + xfer += oprot->writeI64((*_iter542)); } xfer += oprot->writeListEnd(); } @@ -12568,11 +12590,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) { swap(a.txn_ids, b.txn_ids); } -AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) { - txn_ids = other544.txn_ids; +AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other543) { + txn_ids = other543.txn_ids; } -AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) { - txn_ids = other545.txn_ids; +AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other544) { + txn_ids = other544.txn_ids; return *this; } void AbortTxnsRequest::printTo(std::ostream& out) const { @@ -12654,11 +12676,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) { - txnid = other546.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other545) { + txnid = other545.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) { - txnid = other547.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other546) { + txnid = other546.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12736,9 +12758,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast548; - xfer += iprot->readI32(ecast548); - this->type = (LockType::type)ecast548; + int32_t ecast547; + xfer += iprot->readI32(ecast547); + this->type = (LockType::type)ecast547; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12746,9 +12768,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast549; - xfer += iprot->readI32(ecast549); - this->level = (LockLevel::type)ecast549; + int32_t ecast548; + xfer += iprot->readI32(ecast548); + this->level = (LockLevel::type)ecast548; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12780,9 +12802,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast550; - xfer += iprot->readI32(ecast550); - this->operationType = (DataOperationType::type)ecast550; + int32_t ecast549; + xfer += iprot->readI32(ecast549); + this->operationType = (DataOperationType::type)ecast549; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -12882,7 +12904,18 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other551) { +LockComponent::LockComponent(const LockComponent& other550) { + type = other550.type; + level = other550.level; + dbname = other550.dbname; + tablename = other550.tablename; + partitionname = other550.partitionname; + operationType = other550.operationType; + isAcid = other550.isAcid; + isDynamicPartitionWrite = other550.isDynamicPartitionWrite; + __isset = other550.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other551) { type = other551.type; level = other551.level; dbname = other551.dbname; @@ -12892,17 +12925,6 @@ LockComponent::LockComponent(const LockComponent& other551) { isAcid = other551.isAcid; isDynamicPartitionWrite = other551.isDynamicPartitionWrite; __isset = other551.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other552) { - type = other552.type; - level = other552.level; - dbname = other552.dbname; - tablename = other552.tablename; - partitionname = other552.partitionname; - operationType = other552.operationType; - isAcid = other552.isAcid; - isDynamicPartitionWrite = other552.isDynamicPartitionWrite; - __isset = other552.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12974,14 +12996,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size553; - ::apache::thrift::protocol::TType _etype556; - xfer += iprot->readListBegin(_etype556, _size553); - this->component.resize(_size553); - uint32_t _i557; - for (_i557 = 0; _i557 < _size553; ++_i557) + uint32_t _size552; + ::apache::thrift::protocol::TType _etype555; + xfer += iprot->readListBegin(_etype555, _size552); + this->component.resize(_size552); + uint32_t _i556; + for (_i556 = 0; _i556 < _size552; ++_i556) { - xfer += this->component[_i557].read(iprot); + xfer += this->component[_i556].read(iprot); } xfer += iprot->readListEnd(); } @@ -13048,10 +13070,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(this->component.size())); - std::vector ::const_iterator _iter558; - for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558) + std::vector ::const_iterator _iter557; + for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557) { - xfer += (*_iter558).write(oprot); + xfer += (*_iter557).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13090,21 +13112,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other559) { +LockRequest::LockRequest(const LockRequest& other558) { + component = other558.component; + txnid = other558.txnid; + user = other558.user; + hostname = other558.hostname; + agentInfo = other558.agentInfo; + __isset = other558.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other559) { component = other559.component; txnid = other559.txnid; user = other559.user; hostname = other559.hostname; agentInfo = other559.agentInfo; __isset = other559.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other560) { - component = other560.component; - txnid = other560.txnid; - user = other560.user; - hostname = other560.hostname; - agentInfo = other560.agentInfo; - __isset = other560.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -13164,9 +13186,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast561; - xfer += iprot->readI32(ecast561); - this->state = (LockState::type)ecast561; + int32_t ecast560; + xfer += iprot->readI32(ecast560); + this->state = (LockState::type)ecast560; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13212,13 +13234,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other562) { +LockResponse::LockResponse(const LockResponse& other561) { + lockid = other561.lockid; + state = other561.state; +} +LockResponse& LockResponse::operator=(const LockResponse& other562) { lockid = other562.lockid; state = other562.state; -} -LockResponse& LockResponse::operator=(const LockResponse& other563) { - lockid = other563.lockid; - state = other563.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -13340,17 +13362,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other564) { +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other563) { + lockid = other563.lockid; + txnid = other563.txnid; + elapsed_ms = other563.elapsed_ms; + __isset = other563.__isset; +} +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other564) { lockid = other564.lockid; txnid = other564.txnid; elapsed_ms = other564.elapsed_ms; __isset = other564.__isset; -} -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other565) { - lockid = other565.lockid; - txnid = other565.txnid; - elapsed_ms = other565.elapsed_ms; - __isset = other565.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -13434,11 +13456,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other566) { - lockid = other566.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other565) { + lockid = other565.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) { - lockid = other567.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) { + lockid = other566.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -13577,19 +13599,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other568) { +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other567) { + dbname = other567.dbname; + tablename = other567.tablename; + partname = other567.partname; + isExtended = other567.isExtended; + __isset = other567.__isset; +} +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other568) { dbname = other568.dbname; tablename = other568.tablename; partname = other568.partname; isExtended = other568.isExtended; __isset = other568.__isset; -} -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other569) { - dbname = other569.dbname; - tablename = other569.tablename; - partname = other569.partname; - isExtended = other569.isExtended; - __isset = other569.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13742,9 +13764,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast570; - xfer += iprot->readI32(ecast570); - this->state = (LockState::type)ecast570; + int32_t ecast569; + xfer += iprot->readI32(ecast569); + this->state = (LockState::type)ecast569; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13752,9 +13774,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast571; - xfer += iprot->readI32(ecast571); - this->type = (LockType::type)ecast571; + int32_t ecast570; + xfer += iprot->readI32(ecast570); + this->type = (LockType::type)ecast570; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13970,7 +13992,26 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) { +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other571) { + lockid = other571.lockid; + dbname = other571.dbname; + tablename = other571.tablename; + partname = other571.partname; + state = other571.state; + type = other571.type; + txnid = other571.txnid; + lastheartbeat = other571.lastheartbeat; + acquiredat = other571.acquiredat; + user = other571.user; + hostname = other571.hostname; + heartbeatCount = other571.heartbeatCount; + agentInfo = other571.agentInfo; + blockedByExtId = other571.blockedByExtId; + blockedByIntId = other571.blockedByIntId; + lockIdInternal = other571.lockIdInternal; + __isset = other571.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other572) { lockid = other572.lockid; dbname = other572.dbname; tablename = other572.tablename; @@ -13988,25 +14029,6 @@ ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElemen blockedByIntId = other572.blockedByIntId; lockIdInternal = other572.lockIdInternal; __isset = other572.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other573) { - lockid = other573.lockid; - dbname = other573.dbname; - tablename = other573.tablename; - partname = other573.partname; - state = other573.state; - type = other573.type; - txnid = other573.txnid; - lastheartbeat = other573.lastheartbeat; - acquiredat = other573.acquiredat; - user = other573.user; - hostname = other573.hostname; - heartbeatCount = other573.heartbeatCount; - agentInfo = other573.agentInfo; - blockedByExtId = other573.blockedByExtId; - blockedByIntId = other573.blockedByIntId; - lockIdInternal = other573.lockIdInternal; - __isset = other573.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -14065,14 +14087,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size574; - ::apache::thrift::protocol::TType _etype577; - xfer += iprot->readListBegin(_etype577, _size574); - this->locks.resize(_size574); - uint32_t _i578; - for (_i578 = 0; _i578 < _size574; ++_i578) + uint32_t _size573; + ::apache::thrift::protocol::TType _etype576; + xfer += iprot->readListBegin(_etype576, _size573); + this->locks.resize(_size573); + uint32_t _i577; + for (_i577 = 0; _i577 < _size573; ++_i577) { - xfer += this->locks[_i578].read(iprot); + xfer += this->locks[_i577].read(iprot); } xfer += iprot->readListEnd(); } @@ -14101,10 +14123,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(this->locks.size())); - std::vector ::const_iterator _iter579; - for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579) + std::vector ::const_iterator _iter578; + for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578) { - xfer += (*_iter579).write(oprot); + xfer += (*_iter578).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14121,13 +14143,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other580) { +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) { + locks = other579.locks; + __isset = other579.__isset; +} +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other580) { locks = other580.locks; __isset = other580.__isset; -} -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other581) { - locks = other581.locks; - __isset = other581.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -14228,15 +14250,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other582) { +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) { + lockid = other581.lockid; + txnid = other581.txnid; + __isset = other581.__isset; +} +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other582) { lockid = other582.lockid; txnid = other582.txnid; __isset = other582.__isset; -} -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other583) { - lockid = other583.lockid; - txnid = other583.txnid; - __isset = other583.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -14339,13 +14361,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other584) { +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) { + min = other583.min; + max = other583.max; +} +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other584) { min = other584.min; max = other584.max; -} -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other585) { - min = other585.min; - max = other585.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -14396,15 +14418,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size586; - ::apache::thrift::protocol::TType _etype589; - xfer += iprot->readSetBegin(_etype589, _size586); - uint32_t _i590; - for (_i590 = 0; _i590 < _size586; ++_i590) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readSetBegin(_etype588, _size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - int64_t _elem591; - xfer += iprot->readI64(_elem591); - this->aborted.insert(_elem591); + int64_t _elem590; + xfer += iprot->readI64(_elem590); + this->aborted.insert(_elem590); } xfer += iprot->readSetEnd(); } @@ -14417,15 +14439,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size592; - ::apache::thrift::protocol::TType _etype595; - xfer += iprot->readSetBegin(_etype595, _size592); - uint32_t _i596; - for (_i596 = 0; _i596 < _size592; ++_i596) + uint32_t _size591; + ::apache::thrift::protocol::TType _etype594; + xfer += iprot->readSetBegin(_etype594, _size591); + uint32_t _i595; + for (_i595 = 0; _i595 < _size591; ++_i595) { - int64_t _elem597; - xfer += iprot->readI64(_elem597); - this->nosuch.insert(_elem597); + int64_t _elem596; + xfer += iprot->readI64(_elem596); + this->nosuch.insert(_elem596); } xfer += iprot->readSetEnd(); } @@ -14458,10 +14480,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(this->aborted.size())); - std::set ::const_iterator _iter598; - for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598) + std::set ::const_iterator _iter597; + for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597) { - xfer += oprot->writeI64((*_iter598)); + xfer += oprot->writeI64((*_iter597)); } xfer += oprot->writeSetEnd(); } @@ -14470,10 +14492,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(this->nosuch.size())); - std::set ::const_iterator _iter599; - for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599) + std::set ::const_iterator _iter598; + for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598) { - xfer += oprot->writeI64((*_iter599)); + xfer += oprot->writeI64((*_iter598)); } xfer += oprot->writeSetEnd(); } @@ -14490,13 +14512,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other600) { +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) { + aborted = other599.aborted; + nosuch = other599.nosuch; +} +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other600) { aborted = other600.aborted; nosuch = other600.nosuch; -} -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other601) { - aborted = other601.aborted; - nosuch = other601.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -14589,9 +14611,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast602; - xfer += iprot->readI32(ecast602); - this->type = (CompactionType::type)ecast602; + int32_t ecast601; + xfer += iprot->readI32(ecast601); + this->type = (CompactionType::type)ecast601; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14609,17 +14631,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _ktype604; - ::apache::thrift::protocol::TType _vtype605; - xfer += iprot->readMapBegin(_ktype604, _vtype605, _size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size602; + ::apache::thrift::protocol::TType _ktype603; + ::apache::thrift::protocol::TType _vtype604; + xfer += iprot->readMapBegin(_ktype603, _vtype604, _size602); + uint32_t _i606; + for (_i606 = 0; _i606 < _size602; ++_i606) { - std::string _key608; - xfer += iprot->readString(_key608); - std::string& _val609 = this->properties[_key608]; - xfer += iprot->readString(_val609); + std::string _key607; + xfer += iprot->readString(_key607); + std::string& _val608 = this->properties[_key607]; + xfer += iprot->readString(_val608); } xfer += iprot->readMapEnd(); } @@ -14677,11 +14699,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(this->properties.size())); - std::map ::const_iterator _iter610; - for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610) + std::map ::const_iterator _iter609; + for (_iter609 = this->properties.begin(); _iter609 != this->properties.end(); ++_iter609) { - xfer += oprot->writeString(_iter610->first); - xfer += oprot->writeString(_iter610->second); + xfer += oprot->writeString(_iter609->first); + xfer += oprot->writeString(_iter609->second); } xfer += oprot->writeMapEnd(); } @@ -14703,7 +14725,16 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other611) { +CompactionRequest::CompactionRequest(const CompactionRequest& other610) { + dbname = other610.dbname; + tablename = other610.tablename; + partitionname = other610.partitionname; + type = other610.type; + runas = other610.runas; + properties = other610.properties; + __isset = other610.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other611) { dbname = other611.dbname; tablename = other611.tablename; partitionname = other611.partitionname; @@ -14711,15 +14742,6 @@ CompactionRequest::CompactionRequest(const CompactionRequest& other611) { runas = other611.runas; properties = other611.properties; __isset = other611.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other612) { - dbname = other612.dbname; - tablename = other612.tablename; - partitionname = other612.partitionname; - type = other612.type; - runas = other612.runas; - properties = other612.properties; - __isset = other612.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14846,15 +14868,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) { swap(a.accepted, b.accepted); } -CompactionResponse::CompactionResponse(const CompactionResponse& other613) { +CompactionResponse::CompactionResponse(const CompactionResponse& other612) { + id = other612.id; + state = other612.state; + accepted = other612.accepted; +} +CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other613) { id = other613.id; state = other613.state; accepted = other613.accepted; -} -CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other614) { - id = other614.id; - state = other614.state; - accepted = other614.accepted; return *this; } void CompactionResponse::printTo(std::ostream& out) const { @@ -14915,11 +14937,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) { - (void) other615; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other614) { + (void) other614; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) { - (void) other616; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other615) { + (void) other615; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -15045,9 +15067,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast617; - xfer += iprot->readI32(ecast617); - this->type = (CompactionType::type)ecast617; + int32_t ecast616; + xfer += iprot->readI32(ecast616); + this->type = (CompactionType::type)ecast616; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -15234,7 +15256,23 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) { +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other617) { + dbname = other617.dbname; + tablename = other617.tablename; + partitionname = other617.partitionname; + type = other617.type; + state = other617.state; + workerid = other617.workerid; + start = other617.start; + runAs = other617.runAs; + hightestTxnId = other617.hightestTxnId; + metaInfo = other617.metaInfo; + endTime = other617.endTime; + hadoopJobId = other617.hadoopJobId; + id = other617.id; + __isset = other617.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other618) { dbname = other618.dbname; tablename = other618.tablename; partitionname = other618.partitionname; @@ -15249,22 +15287,6 @@ ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponse hadoopJobId = other618.hadoopJobId; id = other618.id; __isset = other618.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other619) { - dbname = other619.dbname; - tablename = other619.tablename; - partitionname = other619.partitionname; - type = other619.type; - state = other619.state; - workerid = other619.workerid; - start = other619.start; - runAs = other619.runAs; - hightestTxnId = other619.hightestTxnId; - metaInfo = other619.metaInfo; - endTime = other619.endTime; - hadoopJobId = other619.hadoopJobId; - id = other619.id; - __isset = other619.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -15321,14 +15343,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size620; - ::apache::thrift::protocol::TType _etype623; - xfer += iprot->readListBegin(_etype623, _size620); - this->compacts.resize(_size620); - uint32_t _i624; - for (_i624 = 0; _i624 < _size620; ++_i624) + uint32_t _size619; + ::apache::thrift::protocol::TType _etype622; + xfer += iprot->readListBegin(_etype622, _size619); + this->compacts.resize(_size619); + uint32_t _i623; + for (_i623 = 0; _i623 < _size619; ++_i623) { - xfer += this->compacts[_i624].read(iprot); + xfer += this->compacts[_i623].read(iprot); } xfer += iprot->readListEnd(); } @@ -15359,10 +15381,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(this->compacts.size())); - std::vector ::const_iterator _iter625; - for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625) + std::vector ::const_iterator _iter624; + for (_iter624 = this->compacts.begin(); _iter624 != this->compacts.end(); ++_iter624) { - xfer += (*_iter625).write(oprot); + xfer += (*_iter624).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15378,11 +15400,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) { - compacts = other626.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other625) { + compacts = other625.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) { - compacts = other627.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other626) { + compacts = other626.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15471,14 +15493,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size628; - ::apache::thrift::protocol::TType _etype631; - xfer += iprot->readListBegin(_etype631, _size628); - this->partitionnames.resize(_size628); - uint32_t _i632; - for (_i632 = 0; _i632 < _size628; ++_i632) + uint32_t _size627; + ::apache::thrift::protocol::TType _etype630; + xfer += iprot->readListBegin(_etype630, _size627); + this->partitionnames.resize(_size627); + uint32_t _i631; + for (_i631 = 0; _i631 < _size627; ++_i631) { - xfer += iprot->readString(this->partitionnames[_i632]); + xfer += iprot->readString(this->partitionnames[_i631]); } xfer += iprot->readListEnd(); } @@ -15489,9 +15511,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast633; - xfer += iprot->readI32(ecast633); - this->operationType = (DataOperationType::type)ecast633; + int32_t ecast632; + xfer += iprot->readI32(ecast632); + this->operationType = (DataOperationType::type)ecast632; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15537,10 +15559,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter634; - for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634) + std::vector ::const_iterator _iter633; + for (_iter633 = this->partitionnames.begin(); _iter633 != this->partitionnames.end(); ++_iter633) { - xfer += oprot->writeString((*_iter634)); + xfer += oprot->writeString((*_iter633)); } xfer += oprot->writeListEnd(); } @@ -15566,21 +15588,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other635) { +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other634) { + txnid = other634.txnid; + dbname = other634.dbname; + tablename = other634.tablename; + partitionnames = other634.partitionnames; + operationType = other634.operationType; + __isset = other634.__isset; +} +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other635) { txnid = other635.txnid; dbname = other635.dbname; tablename = other635.tablename; partitionnames = other635.partitionnames; operationType = other635.operationType; __isset = other635.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other636) { - txnid = other636.txnid; - dbname = other636.dbname; - tablename = other636.tablename; - partitionnames = other636.partitionnames; - operationType = other636.operationType; - __isset = other636.__isset; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -15686,15 +15708,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other637) { +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other636) { + lastEvent = other636.lastEvent; + maxEvents = other636.maxEvents; + __isset = other636.__isset; +} +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other637) { lastEvent = other637.lastEvent; maxEvents = other637.maxEvents; __isset = other637.__isset; -} -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other638) { - lastEvent = other638.lastEvent; - maxEvents = other638.maxEvents; - __isset = other638.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -15895,7 +15917,17 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other639) { +NotificationEvent::NotificationEvent(const NotificationEvent& other638) { + eventId = other638.eventId; + eventTime = other638.eventTime; + eventType = other638.eventType; + dbName = other638.dbName; + tableName = other638.tableName; + message = other638.message; + messageFormat = other638.messageFormat; + __isset = other638.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other639) { eventId = other639.eventId; eventTime = other639.eventTime; eventType = other639.eventType; @@ -15904,16 +15936,6 @@ NotificationEvent::NotificationEvent(const NotificationEvent& other639) { message = other639.message; messageFormat = other639.messageFormat; __isset = other639.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other640) { - eventId = other640.eventId; - eventTime = other640.eventTime; - eventType = other640.eventType; - dbName = other640.dbName; - tableName = other640.tableName; - message = other640.message; - messageFormat = other640.messageFormat; - __isset = other640.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15964,14 +15986,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size641; - ::apache::thrift::protocol::TType _etype644; - xfer += iprot->readListBegin(_etype644, _size641); - this->events.resize(_size641); - uint32_t _i645; - for (_i645 = 0; _i645 < _size641; ++_i645) + uint32_t _size640; + ::apache::thrift::protocol::TType _etype643; + xfer += iprot->readListBegin(_etype643, _size640); + this->events.resize(_size640); + uint32_t _i644; + for (_i644 = 0; _i644 < _size640; ++_i644) { - xfer += this->events[_i645].read(iprot); + xfer += this->events[_i644].read(iprot); } xfer += iprot->readListEnd(); } @@ -16002,10 +16024,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(this->events.size())); - std::vector ::const_iterator _iter646; - for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646) + std::vector ::const_iterator _iter645; + for (_iter645 = this->events.begin(); _iter645 != this->events.end(); ++_iter645) { - xfer += (*_iter646).write(oprot); + xfer += (*_iter645).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16021,11 +16043,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) { - events = other647.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other646) { + events = other646.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) { - events = other648.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other647) { + events = other647.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -16107,11 +16129,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) { - eventId = other649.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other648) { + eventId = other648.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) { - eventId = other650.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other649) { + eventId = other649.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -16174,14 +16196,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size651; - ::apache::thrift::protocol::TType _etype654; - xfer += iprot->readListBegin(_etype654, _size651); - this->filesAdded.resize(_size651); - uint32_t _i655; - for (_i655 = 0; _i655 < _size651; ++_i655) + uint32_t _size650; + ::apache::thrift::protocol::TType _etype653; + xfer += iprot->readListBegin(_etype653, _size650); + this->filesAdded.resize(_size650); + uint32_t _i654; + for (_i654 = 0; _i654 < _size650; ++_i654) { - xfer += iprot->readString(this->filesAdded[_i655]); + xfer += iprot->readString(this->filesAdded[_i654]); } xfer += iprot->readListEnd(); } @@ -16194,14 +16216,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size656; - ::apache::thrift::protocol::TType _etype659; - xfer += iprot->readListBegin(_etype659, _size656); - this->filesAddedChecksum.resize(_size656); - uint32_t _i660; - for (_i660 = 0; _i660 < _size656; ++_i660) + uint32_t _size655; + ::apache::thrift::protocol::TType _etype658; + xfer += iprot->readListBegin(_etype658, _size655); + this->filesAddedChecksum.resize(_size655); + uint32_t _i659; + for (_i659 = 0; _i659 < _size655; ++_i659) { - xfer += iprot->readString(this->filesAddedChecksum[_i660]); + xfer += iprot->readString(this->filesAddedChecksum[_i659]); } xfer += iprot->readListEnd(); } @@ -16237,10 +16259,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(this->filesAdded.size())); - std::vector ::const_iterator _iter661; - for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661) + std::vector ::const_iterator _iter660; + for (_iter660 = this->filesAdded.begin(); _iter660 != this->filesAdded.end(); ++_iter660) { - xfer += oprot->writeString((*_iter661)); + xfer += oprot->writeString((*_iter660)); } xfer += oprot->writeListEnd(); } @@ -16250,10 +16272,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(this->filesAddedChecksum.size())); - std::vector ::const_iterator _iter662; - for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662) + std::vector ::const_iterator _iter661; + for (_iter661 = this->filesAddedChecksum.begin(); _iter661 != this->filesAddedChecksum.end(); ++_iter661) { - xfer += oprot->writeString((*_iter662)); + xfer += oprot->writeString((*_iter661)); } xfer += oprot->writeListEnd(); } @@ -16272,17 +16294,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other663) { +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other662) { + replace = other662.replace; + filesAdded = other662.filesAdded; + filesAddedChecksum = other662.filesAddedChecksum; + __isset = other662.__isset; +} +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other663) { replace = other663.replace; filesAdded = other663.filesAdded; filesAddedChecksum = other663.filesAddedChecksum; __isset = other663.__isset; -} -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other664) { - replace = other664.replace; - filesAdded = other664.filesAdded; - filesAddedChecksum = other664.filesAddedChecksum; - __isset = other664.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -16364,13 +16386,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other665) { +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other664) { + insertData = other664.insertData; + __isset = other664.__isset; +} +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other665) { insertData = other665.insertData; __isset = other665.__isset; -} -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other666) { - insertData = other666.insertData; - __isset = other666.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -16467,14 +16489,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size667; - ::apache::thrift::protocol::TType _etype670; - xfer += iprot->readListBegin(_etype670, _size667); - this->partitionVals.resize(_size667); - uint32_t _i671; - for (_i671 = 0; _i671 < _size667; ++_i671) + uint32_t _size666; + ::apache::thrift::protocol::TType _etype669; + xfer += iprot->readListBegin(_etype669, _size666); + this->partitionVals.resize(_size666); + uint32_t _i670; + for (_i670 = 0; _i670 < _size666; ++_i670) { - xfer += iprot->readString(this->partitionVals[_i671]); + xfer += iprot->readString(this->partitionVals[_i670]); } xfer += iprot->readListEnd(); } @@ -16526,10 +16548,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(this->partitionVals.size())); - std::vector ::const_iterator _iter672; - for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672) + std::vector ::const_iterator _iter671; + for (_iter671 = this->partitionVals.begin(); _iter671 != this->partitionVals.end(); ++_iter671) { - xfer += oprot->writeString((*_iter672)); + xfer += oprot->writeString((*_iter671)); } xfer += oprot->writeListEnd(); } @@ -16550,21 +16572,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other673) { +FireEventRequest::FireEventRequest(const FireEventRequest& other672) { + successful = other672.successful; + data = other672.data; + dbName = other672.dbName; + tableName = other672.tableName; + partitionVals = other672.partitionVals; + __isset = other672.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other673) { successful = other673.successful; data = other673.data; dbName = other673.dbName; tableName = other673.tableName; partitionVals = other673.partitionVals; __isset = other673.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other674) { - successful = other674.successful; - data = other674.data; - dbName = other674.dbName; - tableName = other674.tableName; - partitionVals = other674.partitionVals; - __isset = other674.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16627,11 +16649,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other675) { - (void) other675; +FireEventResponse::FireEventResponse(const FireEventResponse& other674) { + (void) other674; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other676) { - (void) other676; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other675) { + (void) other675; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16731,15 +16753,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other677) { +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other676) { + metadata = other676.metadata; + includeBitset = other676.includeBitset; + __isset = other676.__isset; +} +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other677) { metadata = other677.metadata; includeBitset = other677.includeBitset; __isset = other677.__isset; -} -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other678) { - metadata = other678.metadata; - includeBitset = other678.includeBitset; - __isset = other678.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16790,17 +16812,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size679; - ::apache::thrift::protocol::TType _ktype680; - ::apache::thrift::protocol::TType _vtype681; - xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); - uint32_t _i683; - for (_i683 = 0; _i683 < _size679; ++_i683) + uint32_t _size678; + ::apache::thrift::protocol::TType _ktype679; + ::apache::thrift::protocol::TType _vtype680; + xfer += iprot->readMapBegin(_ktype679, _vtype680, _size678); + uint32_t _i682; + for (_i682 = 0; _i682 < _size678; ++_i682) { - int64_t _key684; - xfer += iprot->readI64(_key684); - MetadataPpdResult& _val685 = this->metadata[_key684]; - xfer += _val685.read(iprot); + int64_t _key683; + xfer += iprot->readI64(_key683); + MetadataPpdResult& _val684 = this->metadata[_key683]; + xfer += _val684.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16841,11 +16863,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter686; - for (_iter686 = this->metadata.begin(); _iter686 != this->metadata.end(); ++_iter686) + std::map ::const_iterator _iter685; + for (_iter685 = this->metadata.begin(); _iter685 != this->metadata.end(); ++_iter685) { - xfer += oprot->writeI64(_iter686->first); - xfer += _iter686->second.write(oprot); + xfer += oprot->writeI64(_iter685->first); + xfer += _iter685->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16866,13 +16888,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other687) { +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other686) { + metadata = other686.metadata; + isSupported = other686.isSupported; +} +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other687) { metadata = other687.metadata; isSupported = other687.isSupported; -} -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other688) { - metadata = other688.metadata; - isSupported = other688.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16933,14 +16955,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size689; - ::apache::thrift::protocol::TType _etype692; - xfer += iprot->readListBegin(_etype692, _size689); - this->fileIds.resize(_size689); - uint32_t _i693; - for (_i693 = 0; _i693 < _size689; ++_i693) + uint32_t _size688; + ::apache::thrift::protocol::TType _etype691; + xfer += iprot->readListBegin(_etype691, _size688); + this->fileIds.resize(_size688); + uint32_t _i692; + for (_i692 = 0; _i692 < _size688; ++_i692) { - xfer += iprot->readI64(this->fileIds[_i693]); + xfer += iprot->readI64(this->fileIds[_i692]); } xfer += iprot->readListEnd(); } @@ -16967,9 +16989,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast694; - xfer += iprot->readI32(ecast694); - this->type = (FileMetadataExprType::type)ecast694; + int32_t ecast693; + xfer += iprot->readI32(ecast693); + this->type = (FileMetadataExprType::type)ecast693; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16999,10 +17021,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter695; - for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695) + std::vector ::const_iterator _iter694; + for (_iter694 = this->fileIds.begin(); _iter694 != this->fileIds.end(); ++_iter694) { - xfer += oprot->writeI64((*_iter695)); + xfer += oprot->writeI64((*_iter694)); } xfer += oprot->writeListEnd(); } @@ -17036,19 +17058,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other696) { +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other695) { + fileIds = other695.fileIds; + expr = other695.expr; + doGetFooters = other695.doGetFooters; + type = other695.type; + __isset = other695.__isset; +} +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other696) { fileIds = other696.fileIds; expr = other696.expr; doGetFooters = other696.doGetFooters; type = other696.type; __isset = other696.__isset; -} -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other697) { - fileIds = other697.fileIds; - expr = other697.expr; - doGetFooters = other697.doGetFooters; - type = other697.type; - __isset = other697.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -17101,17 +17123,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size698; - ::apache::thrift::protocol::TType _ktype699; - ::apache::thrift::protocol::TType _vtype700; - xfer += iprot->readMapBegin(_ktype699, _vtype700, _size698); - uint32_t _i702; - for (_i702 = 0; _i702 < _size698; ++_i702) + uint32_t _size697; + ::apache::thrift::protocol::TType _ktype698; + ::apache::thrift::protocol::TType _vtype699; + xfer += iprot->readMapBegin(_ktype698, _vtype699, _size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - int64_t _key703; - xfer += iprot->readI64(_key703); - std::string& _val704 = this->metadata[_key703]; - xfer += iprot->readBinary(_val704); + int64_t _key702; + xfer += iprot->readI64(_key702); + std::string& _val703 = this->metadata[_key702]; + xfer += iprot->readBinary(_val703); } xfer += iprot->readMapEnd(); } @@ -17152,11 +17174,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter705; - for (_iter705 = this->metadata.begin(); _iter705 != this->metadata.end(); ++_iter705) + std::map ::const_iterator _iter704; + for (_iter704 = this->metadata.begin(); _iter704 != this->metadata.end(); ++_iter704) { - xfer += oprot->writeI64(_iter705->first); - xfer += oprot->writeBinary(_iter705->second); + xfer += oprot->writeI64(_iter704->first); + xfer += oprot->writeBinary(_iter704->second); } xfer += oprot->writeMapEnd(); } @@ -17177,13 +17199,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other706) { +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other705) { + metadata = other705.metadata; + isSupported = other705.isSupported; +} +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other706) { metadata = other706.metadata; isSupported = other706.isSupported; -} -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other707) { - metadata = other707.metadata; - isSupported = other707.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -17229,14 +17251,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size708; - ::apache::thrift::protocol::TType _etype711; - xfer += iprot->readListBegin(_etype711, _size708); - this->fileIds.resize(_size708); - uint32_t _i712; - for (_i712 = 0; _i712 < _size708; ++_i712) + uint32_t _size707; + ::apache::thrift::protocol::TType _etype710; + xfer += iprot->readListBegin(_etype710, _size707); + this->fileIds.resize(_size707); + uint32_t _i711; + for (_i711 = 0; _i711 < _size707; ++_i711) { - xfer += iprot->readI64(this->fileIds[_i712]); + xfer += iprot->readI64(this->fileIds[_i711]); } xfer += iprot->readListEnd(); } @@ -17267,10 +17289,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter713; - for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713) + std::vector ::const_iterator _iter712; + for (_iter712 = this->fileIds.begin(); _iter712 != this->fileIds.end(); ++_iter712) { - xfer += oprot->writeI64((*_iter713)); + xfer += oprot->writeI64((*_iter712)); } xfer += oprot->writeListEnd(); } @@ -17286,11 +17308,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other714) { - fileIds = other714.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other713) { + fileIds = other713.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other715) { - fileIds = other715.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other714) { + fileIds = other714.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -17349,11 +17371,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other716) { - (void) other716; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other715) { + (void) other715; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other717) { - (void) other717; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other716) { + (void) other716; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -17407,14 +17429,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _etype721; - xfer += iprot->readListBegin(_etype721, _size718); - this->fileIds.resize(_size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + uint32_t _size717; + ::apache::thrift::protocol::TType _etype720; + xfer += iprot->readListBegin(_etype720, _size717); + this->fileIds.resize(_size717); + uint32_t _i721; + for (_i721 = 0; _i721 < _size717; ++_i721) { - xfer += iprot->readI64(this->fileIds[_i722]); + xfer += iprot->readI64(this->fileIds[_i721]); } xfer += iprot->readListEnd(); } @@ -17427,14 +17449,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size723; - ::apache::thrift::protocol::TType _etype726; - xfer += iprot->readListBegin(_etype726, _size723); - this->metadata.resize(_size723); - uint32_t _i727; - for (_i727 = 0; _i727 < _size723; ++_i727) + uint32_t _size722; + ::apache::thrift::protocol::TType _etype725; + xfer += iprot->readListBegin(_etype725, _size722); + this->metadata.resize(_size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - xfer += iprot->readBinary(this->metadata[_i727]); + xfer += iprot->readBinary(this->metadata[_i726]); } xfer += iprot->readListEnd(); } @@ -17445,9 +17467,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast728; - xfer += iprot->readI32(ecast728); - this->type = (FileMetadataExprType::type)ecast728; + int32_t ecast727; + xfer += iprot->readI32(ecast727); + this->type = (FileMetadataExprType::type)ecast727; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17477,10 +17499,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter729; - for (_iter729 = this->fileIds.begin(); _iter729 != this->fileIds.end(); ++_iter729) + std::vector ::const_iterator _iter728; + for (_iter728 = this->fileIds.begin(); _iter728 != this->fileIds.end(); ++_iter728) { - xfer += oprot->writeI64((*_iter729)); + xfer += oprot->writeI64((*_iter728)); } xfer += oprot->writeListEnd(); } @@ -17489,10 +17511,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter730; - for (_iter730 = this->metadata.begin(); _iter730 != this->metadata.end(); ++_iter730) + std::vector ::const_iterator _iter729; + for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729) { - xfer += oprot->writeBinary((*_iter730)); + xfer += oprot->writeBinary((*_iter729)); } xfer += oprot->writeListEnd(); } @@ -17516,17 +17538,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other731) { +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other730) { + fileIds = other730.fileIds; + metadata = other730.metadata; + type = other730.type; + __isset = other730.__isset; +} +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other731) { fileIds = other731.fileIds; metadata = other731.metadata; type = other731.type; __isset = other731.__isset; -} -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other732) { - fileIds = other732.fileIds; - metadata = other732.metadata; - type = other732.type; - __isset = other732.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17587,11 +17609,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other733) { - (void) other733; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other732) { + (void) other732; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other734) { - (void) other734; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other733) { + (void) other733; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17635,14 +17657,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size735; - ::apache::thrift::protocol::TType _etype738; - xfer += iprot->readListBegin(_etype738, _size735); - this->fileIds.resize(_size735); - uint32_t _i739; - for (_i739 = 0; _i739 < _size735; ++_i739) + uint32_t _size734; + ::apache::thrift::protocol::TType _etype737; + xfer += iprot->readListBegin(_etype737, _size734); + this->fileIds.resize(_size734); + uint32_t _i738; + for (_i738 = 0; _i738 < _size734; ++_i738) { - xfer += iprot->readI64(this->fileIds[_i739]); + xfer += iprot->readI64(this->fileIds[_i738]); } xfer += iprot->readListEnd(); } @@ -17673,10 +17695,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter740; - for (_iter740 = this->fileIds.begin(); _iter740 != this->fileIds.end(); ++_iter740) + std::vector ::const_iterator _iter739; + for (_iter739 = this->fileIds.begin(); _iter739 != this->fileIds.end(); ++_iter739) { - xfer += oprot->writeI64((*_iter740)); + xfer += oprot->writeI64((*_iter739)); } xfer += oprot->writeListEnd(); } @@ -17692,11 +17714,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other741) { - fileIds = other741.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other740) { + fileIds = other740.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other742) { - fileIds = other742.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other741) { + fileIds = other741.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17778,11 +17800,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other743) { - isSupported = other743.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other742) { + isSupported = other742.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other744) { - isSupported = other744.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other743) { + isSupported = other743.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17923,19 +17945,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other745) { +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other744) { + dbName = other744.dbName; + tblName = other744.tblName; + partName = other744.partName; + isAllParts = other744.isAllParts; + __isset = other744.__isset; +} +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other745) { dbName = other745.dbName; tblName = other745.tblName; partName = other745.partName; isAllParts = other745.isAllParts; __isset = other745.__isset; -} -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other746) { - dbName = other746.dbName; - tblName = other746.tblName; - partName = other746.partName; - isAllParts = other746.isAllParts; - __isset = other746.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17983,14 +18005,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - this->functions.resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size746; + ::apache::thrift::protocol::TType _etype749; + xfer += iprot->readListBegin(_etype749, _size746); + this->functions.resize(_size746); + uint32_t _i750; + for (_i750 = 0; _i750 < _size746; ++_i750) { - xfer += this->functions[_i751].read(iprot); + xfer += this->functions[_i750].read(iprot); } xfer += iprot->readListEnd(); } @@ -18020,10 +18042,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter752; - for (_iter752 = this->functions.begin(); _iter752 != this->functions.end(); ++_iter752) + std::vector ::const_iterator _iter751; + for (_iter751 = this->functions.begin(); _iter751 != this->functions.end(); ++_iter751) { - xfer += (*_iter752).write(oprot); + xfer += (*_iter751).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18040,13 +18062,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other753) { +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other752) { + functions = other752.functions; + __isset = other752.__isset; +} +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other753) { functions = other753.functions; __isset = other753.__isset; -} -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other754) { - functions = other754.functions; - __isset = other754.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -18091,16 +18113,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size755; - ::apache::thrift