You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by we...@apache.org on 2017/05/08 20:43:11 UTC
[21/51] [partial] hive git commit: Revert "HIVE-14671 : merge master
into hive-14535 (Wei Zheng)"
http://git-wip-us.apache.org/repos/asf/hive/blob/ed64a74e/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 cfa2e49..96c2b0b 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -12027,7 +12027,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::vector<int64_t> & val) {
+void GetOpenTxnsResponse::__set_open_txns(const std::set<int64_t> & val) {
this->open_txns = val;
}
@@ -12036,10 +12036,6 @@ 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);
@@ -12054,7 +12050,6 @@ 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)
{
@@ -12073,19 +12068,20 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot)
}
break;
case 2:
- if (ftype == ::apache::thrift::protocol::T_LIST) {
+ if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->open_txns.clear();
uint32_t _size517;
::apache::thrift::protocol::TType _etype520;
- xfer += iprot->readListBegin(_etype520, _size517);
- this->open_txns.resize(_size517);
+ xfer += iprot->readSetBegin(_etype520, _size517);
uint32_t _i521;
for (_i521 = 0; _i521 < _size517; ++_i521)
{
- xfer += iprot->readI64(this->open_txns[_i521]);
+ int64_t _elem522;
+ xfer += iprot->readI64(_elem522);
+ this->open_txns.insert(_elem522);
}
- xfer += iprot->readListEnd();
+ xfer += iprot->readSetEnd();
}
isset_open_txns = true;
} else {
@@ -12100,14 +12096,6 @@ 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;
@@ -12121,8 +12109,6 @@ 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;
}
@@ -12135,15 +12121,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_LIST, 2);
+ xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2);
{
- xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
- std::vector<int64_t> ::const_iterator _iter522;
- for (_iter522 = this->open_txns.begin(); _iter522 != this->open_txns.end(); ++_iter522)
+ xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size()));
+ std::set<int64_t> ::const_iterator _iter523;
+ for (_iter523 = this->open_txns.begin(); _iter523 != this->open_txns.end(); ++_iter523)
{
- xfer += oprot->writeI64((*_iter522));
+ xfer += oprot->writeI64((*_iter523));
}
- xfer += oprot->writeListEnd();
+ xfer += oprot->writeSetEnd();
}
xfer += oprot->writeFieldEnd();
@@ -12152,10 +12138,6 @@ 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;
@@ -12166,23 +12148,20 @@ 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& 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) {
+GetOpenTxnsResponse::GetOpenTxnsResponse(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 {
@@ -12191,7 +12170,6 @@ 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 << "<null>"));
- out << ", " << "abortedBits=" << to_string(abortedBits);
out << ")";
}
@@ -12327,19 +12305,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+OpenTxnRequest::OpenTxnRequest(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 {
@@ -12387,14 +12365,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->txn_ids[_i531]);
+ xfer += iprot->readI64(this->txn_ids[_i532]);
}
xfer += iprot->readListEnd();
}
@@ -12425,10 +12403,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter532;
- for (_iter532 = this->txn_ids.begin(); _iter532 != this->txn_ids.end(); ++_iter532)
+ std::vector<int64_t> ::const_iterator _iter533;
+ for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533)
{
- xfer += oprot->writeI64((*_iter532));
+ xfer += oprot->writeI64((*_iter533));
}
xfer += oprot->writeListEnd();
}
@@ -12444,11 +12422,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) {
swap(a.txn_ids, b.txn_ids);
}
-OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other533) {
- txn_ids = other533.txn_ids;
-}
-OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other534) {
+OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other534) {
txn_ids = other534.txn_ids;
+}
+OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other535) {
+ txn_ids = other535.txn_ids;
return *this;
}
void OpenTxnsResponse::printTo(std::ostream& out) const {
@@ -12530,11 +12508,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other535) {
- txnid = other535.txnid;
-}
-AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other536) {
+AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other536) {
txnid = other536.txnid;
+}
+AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other537) {
+ txnid = other537.txnid;
return *this;
}
void AbortTxnRequest::printTo(std::ostream& out) const {
@@ -12579,14 +12557,14 @@ uint32_t AbortTxnsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->txn_ids.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->txn_ids[_i541]);
+ xfer += iprot->readI64(this->txn_ids[_i542]);
}
xfer += iprot->readListEnd();
}
@@ -12617,10 +12595,10 @@ uint32_t AbortTxnsRequest::write(::apache::thrift::protocol::TProtocol* oprot) c
xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size()));
- std::vector<int64_t> ::const_iterator _iter542;
- for (_iter542 = this->txn_ids.begin(); _iter542 != this->txn_ids.end(); ++_iter542)
+ std::vector<int64_t> ::const_iterator _iter543;
+ for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543)
{
- xfer += oprot->writeI64((*_iter542));
+ xfer += oprot->writeI64((*_iter543));
}
xfer += oprot->writeListEnd();
}
@@ -12636,11 +12614,11 @@ void swap(AbortTxnsRequest &a, AbortTxnsRequest &b) {
swap(a.txn_ids, b.txn_ids);
}
-AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other543) {
- txn_ids = other543.txn_ids;
-}
-AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other544) {
+AbortTxnsRequest::AbortTxnsRequest(const AbortTxnsRequest& other544) {
txn_ids = other544.txn_ids;
+}
+AbortTxnsRequest& AbortTxnsRequest::operator=(const AbortTxnsRequest& other545) {
+ txn_ids = other545.txn_ids;
return *this;
}
void AbortTxnsRequest::printTo(std::ostream& out) const {
@@ -12722,11 +12700,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) {
swap(a.txnid, b.txnid);
}
-CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other545) {
- txnid = other545.txnid;
-}
-CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other546) {
+CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other546) {
txnid = other546.txnid;
+}
+CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other547) {
+ txnid = other547.txnid;
return *this;
}
void CommitTxnRequest::printTo(std::ostream& out) const {
@@ -12804,9 +12782,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
{
case 1:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast547;
- xfer += iprot->readI32(ecast547);
- this->type = (LockType::type)ecast547;
+ int32_t ecast548;
+ xfer += iprot->readI32(ecast548);
+ this->type = (LockType::type)ecast548;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -12814,9 +12792,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast548;
- xfer += iprot->readI32(ecast548);
- this->level = (LockLevel::type)ecast548;
+ int32_t ecast549;
+ xfer += iprot->readI32(ecast549);
+ this->level = (LockLevel::type)ecast549;
isset_level = true;
} else {
xfer += iprot->skip(ftype);
@@ -12848,9 +12826,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast549;
- xfer += iprot->readI32(ecast549);
- this->operationType = (DataOperationType::type)ecast549;
+ int32_t ecast550;
+ xfer += iprot->readI32(ecast550);
+ this->operationType = (DataOperationType::type)ecast550;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -12950,18 +12928,7 @@ void swap(LockComponent &a, LockComponent &b) {
swap(a.__isset, b.__isset);
}
-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) {
+LockComponent::LockComponent(const LockComponent& other551) {
type = other551.type;
level = other551.level;
dbname = other551.dbname;
@@ -12971,6 +12938,17 @@ LockComponent& LockComponent::operator=(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 {
@@ -13042,14 +13020,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->component.clear();
- 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)
+ 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)
{
- xfer += this->component[_i556].read(iprot);
+ xfer += this->component[_i557].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -13116,10 +13094,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 _iter557;
- for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557)
+ std::vector<LockComponent> ::const_iterator _iter558;
+ for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558)
{
- xfer += (*_iter557).write(oprot);
+ xfer += (*_iter558).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13158,21 +13136,21 @@ void swap(LockRequest &a, LockRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+LockRequest::LockRequest(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 {
@@ -13232,9 +13210,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 2:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast560;
- xfer += iprot->readI32(ecast560);
- this->state = (LockState::type)ecast560;
+ int32_t ecast561;
+ xfer += iprot->readI32(ecast561);
+ this->state = (LockState::type)ecast561;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13280,13 +13258,13 @@ void swap(LockResponse &a, LockResponse &b) {
swap(a.state, b.state);
}
-LockResponse::LockResponse(const LockResponse& other561) {
- lockid = other561.lockid;
- state = other561.state;
-}
-LockResponse& LockResponse::operator=(const LockResponse& other562) {
+LockResponse::LockResponse(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 {
@@ -13408,17 +13386,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+CheckLockRequest::CheckLockRequest(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 {
@@ -13502,11 +13480,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) {
swap(a.lockid, b.lockid);
}
-UnlockRequest::UnlockRequest(const UnlockRequest& other565) {
- lockid = other565.lockid;
-}
-UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other566) {
+UnlockRequest::UnlockRequest(const UnlockRequest& other566) {
lockid = other566.lockid;
+}
+UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other567) {
+ lockid = other567.lockid;
return *this;
}
void UnlockRequest::printTo(std::ostream& out) const {
@@ -13645,19 +13623,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+ShowLocksRequest::ShowLocksRequest(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 {
@@ -13810,9 +13788,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast569;
- xfer += iprot->readI32(ecast569);
- this->state = (LockState::type)ecast569;
+ int32_t ecast570;
+ xfer += iprot->readI32(ecast570);
+ this->state = (LockState::type)ecast570;
isset_state = true;
} else {
xfer += iprot->skip(ftype);
@@ -13820,9 +13798,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i
break;
case 6:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast570;
- xfer += iprot->readI32(ecast570);
- this->type = (LockType::type)ecast570;
+ int32_t ecast571;
+ xfer += iprot->readI32(ecast571);
+ this->type = (LockType::type)ecast571;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14038,26 +14016,7 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) {
swap(a.__isset, b.__isset);
}
-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) {
+ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other572) {
lockid = other572.lockid;
dbname = other572.dbname;
tablename = other572.tablename;
@@ -14075,6 +14034,25 @@ ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksRes
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 {
@@ -14133,14 +14111,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->locks.clear();
- 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)
+ 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)
{
- xfer += this->locks[_i577].read(iprot);
+ xfer += this->locks[_i578].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -14169,10 +14147,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 _iter578;
- for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter579;
+ for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579)
{
- xfer += (*_iter578).write(oprot);
+ xfer += (*_iter579).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -14189,13 +14167,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) {
swap(a.__isset, b.__isset);
}
-ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other579) {
- locks = other579.locks;
- __isset = other579.__isset;
-}
-ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other580) {
+ShowLocksResponse::ShowLocksResponse(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 {
@@ -14296,15 +14274,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) {
swap(a.__isset, b.__isset);
}
-HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other581) {
- lockid = other581.lockid;
- txnid = other581.txnid;
- __isset = other581.__isset;
-}
-HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other582) {
+HeartbeatRequest::HeartbeatRequest(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 {
@@ -14407,13 +14385,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) {
swap(a.max, b.max);
}
-HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other583) {
- min = other583.min;
- max = other583.max;
-}
-HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other584) {
+HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(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 {
@@ -14464,15 +14442,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->aborted.clear();
- uint32_t _size585;
- ::apache::thrift::protocol::TType _etype588;
- xfer += iprot->readSetBegin(_etype588, _size585);
- uint32_t _i589;
- for (_i589 = 0; _i589 < _size585; ++_i589)
+ uint32_t _size586;
+ ::apache::thrift::protocol::TType _etype589;
+ xfer += iprot->readSetBegin(_etype589, _size586);
+ uint32_t _i590;
+ for (_i590 = 0; _i590 < _size586; ++_i590)
{
- int64_t _elem590;
- xfer += iprot->readI64(_elem590);
- this->aborted.insert(_elem590);
+ int64_t _elem591;
+ xfer += iprot->readI64(_elem591);
+ this->aborted.insert(_elem591);
}
xfer += iprot->readSetEnd();
}
@@ -14485,15 +14463,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_SET) {
{
this->nosuch.clear();
- uint32_t _size591;
- ::apache::thrift::protocol::TType _etype594;
- xfer += iprot->readSetBegin(_etype594, _size591);
- uint32_t _i595;
- for (_i595 = 0; _i595 < _size591; ++_i595)
+ uint32_t _size592;
+ ::apache::thrift::protocol::TType _etype595;
+ xfer += iprot->readSetBegin(_etype595, _size592);
+ uint32_t _i596;
+ for (_i596 = 0; _i596 < _size592; ++_i596)
{
- int64_t _elem596;
- xfer += iprot->readI64(_elem596);
- this->nosuch.insert(_elem596);
+ int64_t _elem597;
+ xfer += iprot->readI64(_elem597);
+ this->nosuch.insert(_elem597);
}
xfer += iprot->readSetEnd();
}
@@ -14526,10 +14504,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 _iter597;
- for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597)
+ std::set<int64_t> ::const_iterator _iter598;
+ for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598)
{
- xfer += oprot->writeI64((*_iter597));
+ xfer += oprot->writeI64((*_iter598));
}
xfer += oprot->writeSetEnd();
}
@@ -14538,10 +14516,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 _iter598;
- for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598)
+ std::set<int64_t> ::const_iterator _iter599;
+ for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599)
{
- xfer += oprot->writeI64((*_iter598));
+ xfer += oprot->writeI64((*_iter599));
}
xfer += oprot->writeSetEnd();
}
@@ -14558,13 +14536,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) {
swap(a.nosuch, b.nosuch);
}
-HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other599) {
- aborted = other599.aborted;
- nosuch = other599.nosuch;
-}
-HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other600) {
+HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(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 {
@@ -14657,9 +14635,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast601;
- xfer += iprot->readI32(ecast601);
- this->type = (CompactionType::type)ecast601;
+ int32_t ecast602;
+ xfer += iprot->readI32(ecast602);
+ this->type = (CompactionType::type)ecast602;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -14677,17 +14655,17 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->properties.clear();
- 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)
+ 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)
{
- std::string _key607;
- xfer += iprot->readString(_key607);
- std::string& _val608 = this->properties[_key607];
- xfer += iprot->readString(_val608);
+ std::string _key608;
+ xfer += iprot->readString(_key608);
+ std::string& _val609 = this->properties[_key608];
+ xfer += iprot->readString(_val609);
}
xfer += iprot->readMapEnd();
}
@@ -14745,11 +14723,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 _iter609;
- for (_iter609 = this->properties.begin(); _iter609 != this->properties.end(); ++_iter609)
+ std::map<std::string, std::string> ::const_iterator _iter610;
+ for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610)
{
- xfer += oprot->writeString(_iter609->first);
- xfer += oprot->writeString(_iter609->second);
+ xfer += oprot->writeString(_iter610->first);
+ xfer += oprot->writeString(_iter610->second);
}
xfer += oprot->writeMapEnd();
}
@@ -14771,16 +14749,7 @@ void swap(CompactionRequest &a, CompactionRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+CompactionRequest::CompactionRequest(const CompactionRequest& other611) {
dbname = other611.dbname;
tablename = other611.tablename;
partitionname = other611.partitionname;
@@ -14788,6 +14757,15 @@ CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other61
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 {
@@ -14914,15 +14892,15 @@ void swap(CompactionResponse &a, CompactionResponse &b) {
swap(a.accepted, b.accepted);
}
-CompactionResponse::CompactionResponse(const CompactionResponse& other612) {
- id = other612.id;
- state = other612.state;
- accepted = other612.accepted;
-}
-CompactionResponse& CompactionResponse::operator=(const CompactionResponse& other613) {
+CompactionResponse::CompactionResponse(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 {
@@ -14983,11 +14961,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) {
(void) b;
}
-ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other614) {
- (void) other614;
-}
-ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other615) {
+ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) {
(void) other615;
+}
+ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) {
+ (void) other616;
return *this;
}
void ShowCompactRequest::printTo(std::ostream& out) const {
@@ -15113,9 +15091,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol*
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast616;
- xfer += iprot->readI32(ecast616);
- this->type = (CompactionType::type)ecast616;
+ int32_t ecast617;
+ xfer += iprot->readI32(ecast617);
+ this->type = (CompactionType::type)ecast617;
isset_type = true;
} else {
xfer += iprot->skip(ftype);
@@ -15302,23 +15280,7 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) {
swap(a.__isset, b.__isset);
}
-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) {
+ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) {
dbname = other618.dbname;
tablename = other618.tablename;
partitionname = other618.partitionname;
@@ -15333,6 +15295,22 @@ ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowComp
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 {
@@ -15389,14 +15367,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot)
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->compacts.clear();
- 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)
+ 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)
{
- xfer += this->compacts[_i623].read(iprot);
+ xfer += this->compacts[_i624].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -15427,10 +15405,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 _iter624;
- for (_iter624 = this->compacts.begin(); _iter624 != this->compacts.end(); ++_iter624)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter625;
+ for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625)
{
- xfer += (*_iter624).write(oprot);
+ xfer += (*_iter625).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -15446,11 +15424,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) {
swap(a.compacts, b.compacts);
}
-ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other625) {
- compacts = other625.compacts;
-}
-ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other626) {
+ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) {
compacts = other626.compacts;
+}
+ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) {
+ compacts = other627.compacts;
return *this;
}
void ShowCompactResponse::printTo(std::ostream& out) const {
@@ -15539,14 +15517,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionnames.clear();
- 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)
+ 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)
{
- xfer += iprot->readString(this->partitionnames[_i631]);
+ xfer += iprot->readString(this->partitionnames[_i632]);
}
xfer += iprot->readListEnd();
}
@@ -15557,9 +15535,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot
break;
case 5:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast632;
- xfer += iprot->readI32(ecast632);
- this->operationType = (DataOperationType::type)ecast632;
+ int32_t ecast633;
+ xfer += iprot->readI32(ecast633);
+ this->operationType = (DataOperationType::type)ecast633;
this->__isset.operationType = true;
} else {
xfer += iprot->skip(ftype);
@@ -15605,10 +15583,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro
xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionnames.size()));
- std::vector<std::string> ::const_iterator _iter633;
- for (_iter633 = this->partitionnames.begin(); _iter633 != this->partitionnames.end(); ++_iter633)
+ std::vector<std::string> ::const_iterator _iter634;
+ for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634)
{
- xfer += oprot->writeString((*_iter633));
+ xfer += oprot->writeString((*_iter634));
}
xfer += oprot->writeListEnd();
}
@@ -15634,21 +15612,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) {
swap(a.__isset, b.__isset);
}
-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) {
+AddDynamicPartitions::AddDynamicPartitions(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 {
@@ -15754,15 +15732,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) {
swap(a.__isset, b.__isset);
}
-NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other636) {
- lastEvent = other636.lastEvent;
- maxEvents = other636.maxEvents;
- __isset = other636.__isset;
-}
-NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other637) {
+NotificationEventRequest::NotificationEventRequest(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 {
@@ -15963,17 +15941,7 @@ void swap(NotificationEvent &a, NotificationEvent &b) {
swap(a.__isset, b.__isset);
}
-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) {
+NotificationEvent::NotificationEvent(const NotificationEvent& other639) {
eventId = other639.eventId;
eventTime = other639.eventTime;
eventType = other639.eventType;
@@ -15982,6 +15950,16 @@ NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other63
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 {
@@ -16032,14 +16010,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol*
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->events.clear();
- 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)
+ 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)
{
- xfer += this->events[_i644].read(iprot);
+ xfer += this->events[_i645].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -16070,10 +16048,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 _iter645;
- for (_iter645 = this->events.begin(); _iter645 != this->events.end(); ++_iter645)
+ std::vector<NotificationEvent> ::const_iterator _iter646;
+ for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646)
{
- xfer += (*_iter645).write(oprot);
+ xfer += (*_iter646).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -16089,11 +16067,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) {
swap(a.events, b.events);
}
-NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other646) {
- events = other646.events;
-}
-NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other647) {
+NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) {
events = other647.events;
+}
+NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) {
+ events = other648.events;
return *this;
}
void NotificationEventResponse::printTo(std::ostream& out) const {
@@ -16175,11 +16153,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) {
swap(a.eventId, b.eventId);
}
-CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other648) {
- eventId = other648.eventId;
-}
-CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other649) {
+CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) {
eventId = other649.eventId;
+}
+CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) {
+ eventId = other650.eventId;
return *this;
}
void CurrentNotificationEventId::printTo(std::ostream& out) const {
@@ -16194,11 +16172,6 @@ InsertEventRequestData::~InsertEventRequestData() throw() {
}
-void InsertEventRequestData::__set_replace(const bool val) {
- this->replace = val;
-__isset.replace = true;
-}
-
void InsertEventRequestData::__set_filesAdded(const std::vector<std::string> & val) {
this->filesAdded = val;
}
@@ -16231,25 +16204,17 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
switch (fid)
{
case 1:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool(this->replace);
- this->__isset.replace = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- case 2:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAdded.clear();
- 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)
+ 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)
{
- xfer += iprot->readString(this->filesAdded[_i654]);
+ xfer += iprot->readString(this->filesAdded[_i655]);
}
xfer += iprot->readListEnd();
}
@@ -16258,18 +16223,18 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
xfer += iprot->skip(ftype);
}
break;
- case 3:
+ case 2:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->filesAddedChecksum.clear();
- 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)
+ 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)
{
- xfer += iprot->readString(this->filesAddedChecksum[_i659]);
+ xfer += iprot->readString(this->filesAddedChecksum[_i660]);
}
xfer += iprot->readListEnd();
}
@@ -16297,31 +16262,26 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
xfer += oprot->writeStructBegin("InsertEventRequestData");
- if (this->__isset.replace) {
- xfer += oprot->writeFieldBegin("replace", ::apache::thrift::protocol::T_BOOL, 1);
- xfer += oprot->writeBool(this->replace);
- xfer += oprot->writeFieldEnd();
- }
- xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2);
+ xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size()));
- std::vector<std::string> ::const_iterator _iter660;
- for (_iter660 = this->filesAdded.begin(); _iter660 != this->filesAdded.end(); ++_iter660)
+ std::vector<std::string> ::const_iterator _iter661;
+ for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661)
{
- xfer += oprot->writeString((*_iter660));
+ xfer += oprot->writeString((*_iter661));
}
xfer += oprot->writeListEnd();
}
xfer += oprot->writeFieldEnd();
if (this->__isset.filesAddedChecksum) {
- xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3);
+ xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 2);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size()));
- std::vector<std::string> ::const_iterator _iter661;
- for (_iter661 = this->filesAddedChecksum.begin(); _iter661 != this->filesAddedChecksum.end(); ++_iter661)
+ std::vector<std::string> ::const_iterator _iter662;
+ for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662)
{
- xfer += oprot->writeString((*_iter661));
+ xfer += oprot->writeString((*_iter662));
}
xfer += oprot->writeListEnd();
}
@@ -16334,30 +16294,26 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
void swap(InsertEventRequestData &a, InsertEventRequestData &b) {
using ::std::swap;
- swap(a.replace, b.replace);
swap(a.filesAdded, b.filesAdded);
swap(a.filesAddedChecksum, b.filesAddedChecksum);
swap(a.__isset, b.__isset);
}
-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;
+InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other663) {
filesAdded = other663.filesAdded;
filesAddedChecksum = other663.filesAddedChecksum;
__isset = other663.__isset;
+}
+InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other664) {
+ filesAdded = other664.filesAdded;
+ filesAddedChecksum = other664.filesAddedChecksum;
+ __isset = other664.__isset;
return *this;
}
void InsertEventRequestData::printTo(std::ostream& out) const {
using ::apache::thrift::to_string;
out << "InsertEventRequestData(";
- out << "replace="; (__isset.replace ? (out << to_string(replace)) : (out << "<null>"));
- out << ", " << "filesAdded=" << to_string(filesAdded);
+ out << "filesAdded=" << to_string(filesAdded);
out << ", " << "filesAddedChecksum="; (__isset.filesAddedChecksum ? (out << to_string(filesAddedChecksum)) : (out << "<null>"));
out << ")";
}
@@ -16432,13 +16388,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) {
swap(a.__isset, b.__isset);
}
-FireEventRequestData::FireEventRequestData(const FireEventRequestData& other664) {
- insertData = other664.insertData;
- __isset = other664.__isset;
-}
-FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other665) {
+FireEventRequestData::FireEventRequestData(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 {
@@ -16535,14 +16491,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partitionVals.clear();
- 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)
+ 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)
{
- xfer += iprot->readString(this->partitionVals[_i670]);
+ xfer += iprot->readString(this->partitionVals[_i671]);
}
xfer += iprot->readListEnd();
}
@@ -16594,10 +16550,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 _iter671;
- for (_iter671 = this->partitionVals.begin(); _iter671 != this->partitionVals.end(); ++_iter671)
+ std::vector<std::string> ::const_iterator _iter672;
+ for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672)
{
- xfer += oprot->writeString((*_iter671));
+ xfer += oprot->writeString((*_iter672));
}
xfer += oprot->writeListEnd();
}
@@ -16618,21 +16574,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+FireEventRequest::FireEventRequest(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 {
@@ -16695,11 +16651,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) {
(void) b;
}
-FireEventResponse::FireEventResponse(const FireEventResponse& other674) {
- (void) other674;
-}
-FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other675) {
+FireEventResponse::FireEventResponse(const FireEventResponse& other675) {
(void) other675;
+}
+FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other676) {
+ (void) other676;
return *this;
}
void FireEventResponse::printTo(std::ostream& out) const {
@@ -16799,15 +16755,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) {
swap(a.__isset, b.__isset);
}
-MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other676) {
- metadata = other676.metadata;
- includeBitset = other676.includeBitset;
- __isset = other676.__isset;
-}
-MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other677) {
+MetadataPpdResult::MetadataPpdResult(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 {
@@ -16858,17 +16814,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->metadata.clear();
- 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)
+ 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)
{
- int64_t _key683;
- xfer += iprot->readI64(_key683);
- MetadataPpdResult& _val684 = this->metadata[_key683];
- xfer += _val684.read(iprot);
+ int64_t _key684;
+ xfer += iprot->readI64(_key684);
+ MetadataPpdResult& _val685 = this->metadata[_key684];
+ xfer += _val685.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -16909,11 +16865,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<uint32_t>(this->metadata.size()));
- std::map<int64_t, MetadataPpdResult> ::const_iterator _iter685;
- for (_iter685 = this->metadata.begin(); _iter685 != this->metadata.end(); ++_iter685)
+ std::map<int64_t, MetadataPpdResult> ::const_iterator _iter686;
+ for (_iter686 = this->metadata.begin(); _iter686 != this->metadata.end(); ++_iter686)
{
- xfer += oprot->writeI64(_iter685->first);
- xfer += _iter685->second.write(oprot);
+ xfer += oprot->writeI64(_iter686->first);
+ xfer += _iter686->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -16934,13 +16890,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) {
swap(a.isSupported, b.isSupported);
}
-GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other686) {
- metadata = other686.metadata;
- isSupported = other686.isSupported;
-}
-GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other687) {
+GetFileMetadataByExprResult::GetFileMetadataByExprResult(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 {
@@ -17001,14 +16957,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fileIds.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->fileIds[_i692]);
+ xfer += iprot->readI64(this->fileIds[_i693]);
}
xfer += iprot->readListEnd();
}
@@ -17035,9 +16991,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco
break;
case 4:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast693;
- xfer += iprot->readI32(ecast693);
- this->type = (FileMetadataExprType::type)ecast693;
+ int32_t ecast694;
+ xfer += iprot->readI32(ecast694);
+ this->type = (FileMetadataExprType::type)ecast694;
this->__isset.type = true;
} else {
xfer += iprot->skip(ftype);
@@ -17067,10 +17023,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<uint32_t>(this->fileIds.size()));
- std::vector<int64_t> ::const_iterator _iter694;
- for (_iter694 = this->fileIds.begin(); _iter694 != this->fileIds.end(); ++_iter694)
+ std::vector<int64_t> ::const_iterator _iter695;
+ for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695)
{
- xfer += oprot->writeI64((*_iter694));
+ xfer += oprot->writeI64((*_iter695));
}
xfer += oprot->writeListEnd();
}
@@ -17104,19 +17060,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(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 {
@@ -17169,17 +17125,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->metadata.clear();
- 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)
+ 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)
{
- int64_t _key702;
- xfer += iprot->readI64(_key702);
- std::string& _val703 = this->metadata[_key702];
- xfer += iprot->readBinary(_val703);
+ int64_t _key703;
+ xfer += iprot->readI64(_key703);
+ std::string& _val704 = this->metadata[_key703];
+ xfer += iprot->readBinary(_val704);
}
xfer += iprot->readMapEnd();
}
@@ -17220,11 +17176,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<uint32_t>(this->metadata.size()));
- std::map<int64_t, std::string> ::const_iterator _iter704;
- for (_iter704 = this->metadata.begin(); _iter704 != this->metadata.end(); ++_iter704)
+ std::map<int64_t, std::string> ::const_iterator _iter705;
+ for (_iter705 = this->metadata.begin(); _iter705 != this->metadata.end(); ++_iter705)
{
- xfer += oprot->writeI64(_iter704->first);
- xfer += oprot->writeBinary(_iter704->second);
+ xfer += oprot->writeI64(_iter705->first);
+ xfer += oprot->writeBinary(_iter705->second);
}
xfer += oprot->writeMapEnd();
}
@@ -17245,13 +17201,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) {
swap(a.isSupported, b.isSupported);
}
-GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other705) {
- metadata = other705.metadata;
- isSupported = other705.isSupported;
-}
-GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other706) {
+GetFileMetadataResult::GetFileMetadataResult(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 {
@@ -17297,14 +17253,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fileIds.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->fileIds[_i711]);
+ xfer += iprot->readI64(this->fileIds[_i712]);
}
xfer += iprot->readListEnd();
}
@@ -17335,10 +17291,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<uint32_t>(this->fileIds.size()));
- std::vector<int64_t> ::const_iterator _iter712;
- for (_iter712 = this->fileIds.begin(); _iter712 != this->fileIds.end(); ++_iter712)
+ std::vector<int64_t> ::const_iterator _iter713;
+ for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713)
{
- xfer += oprot->writeI64((*_iter712));
+ xfer += oprot->writeI64((*_iter713));
}
xfer += oprot->writeListEnd();
}
@@ -17354,11 +17310,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) {
swap(a.fileIds, b.fileIds);
}
-GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other713) {
- fileIds = other713.fileIds;
-}
-GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other714) {
+GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other714) {
fileIds = other714.fileIds;
+}
+GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other715) {
+ fileIds = other715.fileIds;
return *this;
}
void GetFileMetadataRequest::printTo(std::ostream& out) const {
@@ -17417,11 +17373,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) {
(void) b;
}
-PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other715) {
- (void) other715;
-}
-PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other716) {
+PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other716) {
(void) other716;
+}
+PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other717) {
+ (void) other717;
return *this;
}
void PutFileMetadataResult::printTo(std::ostream& out) const {
@@ -17475,14 +17431,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fileIds.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->fileIds[_i721]);
+ xfer += iprot->readI64(this->fileIds[_i722]);
}
xfer += iprot->readListEnd();
}
@@ -17495,14 +17451,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->metadata.clear();
- 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)
+ 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)
{
- xfer += iprot->readBinary(this->metadata[_i726]);
+ xfer += iprot->readBinary(this->metadata[_i727]);
}
xfer += iprot->readListEnd();
}
@@ -17513,9 +17469,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr
break;
case 3:
if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast727;
- xfer += iprot->readI32(ecast727);
- this->type = (FileMetadataExprType::type)ecast727;
+ int32_t ecast728;
+ xfer += iprot->readI32(ecast728);
+ this->type = (FileMetadataExprType::type)ecast728;
this->__isset.type = true;
} else {
xfer += iprot->skip(ftype);
@@ -17545,10 +17501,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<uint32_t>(this->fileIds.size()));
- std::vector<int64_t> ::const_iterator _iter728;
- for (_iter728 = this->fileIds.begin(); _iter728 != this->fileIds.end(); ++_iter728)
+ std::vector<int64_t> ::const_iterator _iter729;
+ for (_iter729 = this->fileIds.begin(); _iter729 != this->fileIds.end(); ++_iter729)
{
- xfer += oprot->writeI64((*_iter728));
+ xfer += oprot->writeI64((*_iter729));
}
xfer += oprot->writeListEnd();
}
@@ -17557,10 +17513,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<uint32_t>(this->metadata.size()));
- std::vector<std::string> ::const_iterator _iter729;
- for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729)
+ std::vector<std::string> ::const_iterator _iter730;
+ for (_iter730 = this->metadata.begin(); _iter730 != this->metadata.end(); ++_iter730)
{
- xfer += oprot->writeBinary((*_iter729));
+ xfer += oprot->writeBinary((*_iter730));
}
xfer += oprot->writeListEnd();
}
@@ -17584,17 +17540,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) {
swap(a.__isset, b.__isset);
}
-PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other730) {
- fileIds = other730.fileIds;
- metadata = other730.metadata;
- type = other730.type;
- __isset = other730.__isset;
-}
-PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other731) {
+PutFileMetadataRequest::PutFileMetadataRequest(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 {
@@ -17655,11 +17611,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) {
(void) b;
}
-ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other732) {
- (void) other732;
-}
-ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other733) {
+ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other733) {
(void) other733;
+}
+ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other734) {
+ (void) other734;
return *this;
}
void ClearFileMetadataResult::printTo(std::ostream& out) const {
@@ -17703,14 +17659,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->fileIds.clear();
- 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)
+ 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)
{
- xfer += iprot->readI64(this->fileIds[_i738]);
+ xfer += iprot->readI64(this->fileIds[_i739]);
}
xfer += iprot->readListEnd();
}
@@ -17741,10 +17697,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<uint32_t>(this->fileIds.size()));
- std::vector<int64_t> ::const_iterator _iter739;
- for (_iter739 = this->fileIds.begin(); _iter739 != this->fileIds.end(); ++_iter739)
+ std::vector<int64_t> ::const_iterator _iter740;
+ for (_iter740 = this->fileIds.begin(); _iter740 != this->fileIds.end(); ++_iter740)
{
- xfer += oprot->writeI64((*_iter739));
+ xfer += oprot->writeI64((*_iter740));
}
xfer += oprot->writeListEnd();
}
@@ -17760,11 +17716,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) {
swap(a.fileIds, b.fileIds);
}
-ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other740) {
- fileIds = other740.fileIds;
-}
-ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other741) {
+ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other741) {
fileIds = other741.fileIds;
+}
+ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other742) {
+ fileIds = other742.fileIds;
return *this;
}
void ClearFileMetadataRequest::printTo(std::ostream& out) const {
@@ -17846,11 +17802,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) {
swap(a.isSupported, b.isSupported);
}
-CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other742) {
- isSupported = other742.isSupported;
-}
-CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other743) {
+CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other743) {
isSupported = other743.isSupported;
+}
+CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other744) {
+ isSupported = other744.isSupported;
return *this;
}
void CacheFileMetadataResult::printTo(std::ostream& out) const {
@@ -17991,19 +17947,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) {
swap(a.__isset, b.__isset);
}
-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) {
+CacheFileMetadataRequest::CacheFileMetadataRequest(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 {
@@ -18108,13 +18064,13 @@ void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b) {
swap(a.tblName, b.tblName);
}
-GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other746) {
- dbName = other746.dbName;
- tblName = other746.tblName;
-}
-GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other747) {
+GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other747) {
dbName = other747.dbName;
tblName = other747.tblName;
+}
+GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(const GetNextWriteIdRequest& other748) {
+ dbName = other748.dbName;
+ tblName = other748.tblName;
return *this;
}
void GetNextWriteIdRequest::printTo(std::ostream& out) const {
@@ -18197,11 +18153,11 @@ void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b) {
swap(a.writeId, b.writeId);
}
-GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other748) {
- writeId = other748.writeId;
-}
-GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other749) {
+GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other749) {
writeId = other749.writeId;
+}
+GetNextWriteIdResult& GetNextWriteIdResult::operator=(const GetNextWriteIdResult& other750) {
+ writeId = other750.writeId;
return *this;
}
void GetN
<TRUNCATED>