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/05 17:32:08 UTC
[21/51] [partial] hive git commit: HIVE-14671 : merge master into
hive-14535 (Wei Zheng)
http://git-wip-us.apache.org/repos/asf/hive/blob/187eb760/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 96c2b0b..cfa2e49 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::set<int64_t> & val) {
+void GetOpenTxnsResponse::__set_open_txns(const std::vector<int64_t> & val) {
this->open_txns = val;
}
@@ -12036,6 +12036,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);
@@ -12050,6 +12054,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)
{
@@ -12068,20 +12073,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 {
@@ -12096,6 +12100,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;
@@ -12109,6 +12121,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;
}
@@ -12121,15 +12135,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<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->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->writeI64((*_iter523));
+ xfer += oprot->writeI64((*_iter522));
}
- xfer += oprot->writeSetEnd();
+ xfer += oprot->writeListEnd();
}
xfer += oprot->writeFieldEnd();
@@ -12138,6 +12152,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;
@@ -12148,20 +12166,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 {
@@ -12170,6 +12191,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 << "<null>"));
+ out << ", " << "abortedBits=" << to_string(abortedBits);
out << ")";
}
@@ -12305,19 +12327,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 {
@@ -12365,14 +12387,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();
}
@@ -12403,10 +12425,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 _iter533;
- for (_iter533 = this->txn_ids.begin(); _iter533 != this->txn_ids.end(); ++_iter533)
+ std::vector<int64_t> ::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();
}
@@ -12422,11 +12444,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 {
@@ -12508,11 +12530,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 {
@@ -12557,14 +12579,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();
}
@@ -12595,10 +12617,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 _iter543;
- for (_iter543 = this->txn_ids.begin(); _iter543 != this->txn_ids.end(); ++_iter543)
+ std::vector<int64_t> ::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();
}
@@ -12614,11 +12636,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 {
@@ -12700,11 +12722,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 {
@@ -12782,9 +12804,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);
@@ -12792,9 +12814,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);
@@ -12826,9 +12848,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);
@@ -12928,7 +12950,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;
@@ -12938,17 +12971,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 {
@@ -13020,14 +13042,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();
}
@@ -13094,10 +13116,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 _iter558;
- for (_iter558 = this->component.begin(); _iter558 != this->component.end(); ++_iter558)
+ std::vector<LockComponent> ::const_iterator _iter557;
+ for (_iter557 = this->component.begin(); _iter557 != this->component.end(); ++_iter557)
{
- xfer += (*_iter558).write(oprot);
+ xfer += (*_iter557).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -13136,21 +13158,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 {
@@ -13210,9 +13232,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);
@@ -13258,13 +13280,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 {
@@ -13386,17 +13408,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 {
@@ -13480,11 +13502,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 {
@@ -13623,19 +13645,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 {
@@ -13788,9 +13810,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);
@@ -13798,9 +13820,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);
@@ -14016,7 +14038,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;
@@ -14034,25 +14075,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 {
@@ -14111,14 +14133,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();
}
@@ -14147,10 +14169,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 _iter579;
- for (_iter579 = this->locks.begin(); _iter579 != this->locks.end(); ++_iter579)
+ std::vector<ShowLocksResponseElement> ::const_iterator _iter578;
+ for (_iter578 = this->locks.begin(); _iter578 != this->locks.end(); ++_iter578)
{
- xfer += (*_iter579).write(oprot);
+ xfer += (*_iter578).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -14167,13 +14189,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 {
@@ -14274,15 +14296,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 {
@@ -14385,13 +14407,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 {
@@ -14442,15 +14464,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();
}
@@ -14463,15 +14485,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();
}
@@ -14504,10 +14526,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 _iter598;
- for (_iter598 = this->aborted.begin(); _iter598 != this->aborted.end(); ++_iter598)
+ std::set<int64_t> ::const_iterator _iter597;
+ for (_iter597 = this->aborted.begin(); _iter597 != this->aborted.end(); ++_iter597)
{
- xfer += oprot->writeI64((*_iter598));
+ xfer += oprot->writeI64((*_iter597));
}
xfer += oprot->writeSetEnd();
}
@@ -14516,10 +14538,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 _iter599;
- for (_iter599 = this->nosuch.begin(); _iter599 != this->nosuch.end(); ++_iter599)
+ std::set<int64_t> ::const_iterator _iter598;
+ for (_iter598 = this->nosuch.begin(); _iter598 != this->nosuch.end(); ++_iter598)
{
- xfer += oprot->writeI64((*_iter599));
+ xfer += oprot->writeI64((*_iter598));
}
xfer += oprot->writeSetEnd();
}
@@ -14536,13 +14558,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 {
@@ -14635,9 +14657,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);
@@ -14655,17 +14677,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();
}
@@ -14723,11 +14745,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 _iter610;
- for (_iter610 = this->properties.begin(); _iter610 != this->properties.end(); ++_iter610)
+ std::map<std::string, std::string> ::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();
}
@@ -14749,7 +14771,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;
@@ -14757,15 +14788,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 {
@@ -14892,15 +14914,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 {
@@ -14961,11 +14983,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 {
@@ -15091,9 +15113,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);
@@ -15280,7 +15302,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;
@@ -15295,22 +15333,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 {
@@ -15367,14 +15389,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();
}
@@ -15405,10 +15427,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 _iter625;
- for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625)
+ std::vector<ShowCompactResponseElement> ::const_iterator _iter624;
+ for (_iter624 = this->compacts.begin(); _iter624 != this->compacts.end(); ++_iter624)
{
- xfer += (*_iter625).write(oprot);
+ xfer += (*_iter624).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -15424,11 +15446,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 {
@@ -15517,14 +15539,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();
}
@@ -15535,9 +15557,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);
@@ -15583,10 +15605,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 _iter634;
- for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634)
+ std::vector<std::string> ::const_iterator _iter633;
+ for (_iter633 = this->partitionnames.begin(); _iter633 != this->partitionnames.end(); ++_iter633)
{
- xfer += oprot->writeString((*_iter634));
+ xfer += oprot->writeString((*_iter633));
}
xfer += oprot->writeListEnd();
}
@@ -15612,21 +15634,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 {
@@ -15732,15 +15754,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 {
@@ -15941,7 +15963,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;
@@ -15950,16 +15982,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 {
@@ -16010,14 +16032,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();
}
@@ -16048,10 +16070,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 _iter646;
- for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646)
+ std::vector<NotificationEvent> ::const_iterator _iter645;
+ for (_iter645 = this->events.begin(); _iter645 != this->events.end(); ++_iter645)
{
- xfer += (*_iter646).write(oprot);
+ xfer += (*_iter645).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -16067,11 +16089,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 {
@@ -16153,11 +16175,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 {
@@ -16172,6 +16194,11 @@ 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;
}
@@ -16204,17 +16231,25 @@ 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 _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();
}
@@ -16223,18 +16258,18 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr
xfer += iprot->skip(ftype);
}
break;
- case 2:
+ case 3:
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();
}
@@ -16262,26 +16297,31 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op
apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
xfer += oprot->writeStructBegin("InsertEventRequestData");
- xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1);
+ 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->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size()));
- std::vector<std::string> ::const_iterator _iter661;
- for (_iter661 = this->filesAdded.begin(); _iter661 != this->filesAdded.end(); ++_iter661)
+ std::vector<std::string> ::const_iterator _iter660;
+ for (_iter660 = this->filesAdded.begin(); _iter660 != this->filesAdded.end(); ++_iter660)
{
- xfer += oprot->writeString((*_iter661));
+ xfer += oprot->writeString((*_iter660));
}
xfer += oprot->writeListEnd();
}
xfer += oprot->writeFieldEnd();
if (this->__isset.filesAddedChecksum) {
- xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 2);
+ xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size()));
- std::vector<std::string> ::const_iterator _iter662;
- for (_iter662 = this->filesAddedChecksum.begin(); _iter662 != this->filesAddedChecksum.end(); ++_iter662)
+ std::vector<std::string> ::const_iterator _iter661;
+ for (_iter661 = this->filesAddedChecksum.begin(); _iter661 != this->filesAddedChecksum.end(); ++_iter661)
{
- xfer += oprot->writeString((*_iter662));
+ xfer += oprot->writeString((*_iter661));
}
xfer += oprot->writeListEnd();
}
@@ -16294,26 +16334,30 @@ 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& 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) {
- 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 << "filesAdded=" << to_string(filesAdded);
+ out << "replace="; (__isset.replace ? (out << to_string(replace)) : (out << "<null>"));
+ out << ", " << "filesAdded=" << to_string(filesAdded);
out << ", " << "filesAddedChecksum="; (__isset.filesAddedChecksum ? (out << to_string(filesAddedChecksum)) : (out << "<null>"));
out << ")";
}
@@ -16388,13 +16432,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 {
@@ -16491,14 +16535,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();
}
@@ -16550,10 +16594,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 _iter672;
- for (_iter672 = this->partitionVals.begin(); _iter672 != this->partitionVals.end(); ++_iter672)
+ std::vector<std::string> ::const_iterator _iter671;
+ for (_iter671 = this->partitionVals.begin(); _iter671 != this->partitionVals.end(); ++_iter671)
{
- xfer += oprot->writeString((*_iter672));
+ xfer += oprot->writeString((*_iter671));
}
xfer += oprot->writeListEnd();
}
@@ -16574,21 +16618,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 {
@@ -16651,11 +16695,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 {
@@ -16755,15 +16799,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 {
@@ -16814,17 +16858,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();
}
@@ -16865,11 +16909,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 _iter686;
- for (_iter686 = this->metadata.begin(); _iter686 != this->metadata.end(); ++_iter686)
+ std::map<int64_t, MetadataPpdResult> ::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();
}
@@ -16890,13 +16934,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 {
@@ -16957,14 +17001,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();
}
@@ -16991,9 +17035,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);
@@ -17023,10 +17067,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 _iter695;
- for (_iter695 = this->fileIds.begin(); _iter695 != this->fileIds.end(); ++_iter695)
+ std::vector<int64_t> ::const_iterator _iter694;
+ for (_iter694 = this->fileIds.begin(); _iter694 != this->fileIds.end(); ++_iter694)
{
- xfer += oprot->writeI64((*_iter695));
+ xfer += oprot->writeI64((*_iter694));
}
xfer += oprot->writeListEnd();
}
@@ -17060,19 +17104,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 {
@@ -17125,17 +17169,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();
}
@@ -17176,11 +17220,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 _iter705;
- for (_iter705 = this->metadata.begin(); _iter705 != this->metadata.end(); ++_iter705)
+ std::map<int64_t, std::string> ::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();
}
@@ -17201,13 +17245,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 {
@@ -17253,14 +17297,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();
}
@@ -17291,10 +17335,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 _iter713;
- for (_iter713 = this->fileIds.begin(); _iter713 != this->fileIds.end(); ++_iter713)
+ std::vector<int64_t> ::const_iterator _iter712;
+ for (_iter712 = this->fileIds.begin(); _iter712 != this->fileIds.end(); ++_iter712)
{
- xfer += oprot->writeI64((*_iter713));
+ xfer += oprot->writeI64((*_iter712));
}
xfer += oprot->writeListEnd();
}
@@ -17310,11 +17354,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 {
@@ -17373,11 +17417,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 {
@@ -17431,14 +17475,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();
}
@@ -17451,14 +17495,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();
}
@@ -17469,9 +17513,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);
@@ -17501,10 +17545,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 _iter729;
- for (_iter729 = this->fileIds.begin(); _iter729 != this->fileIds.end(); ++_iter729)
+ std::vector<int64_t> ::const_iterator _iter728;
+ for (_iter728 = this->fileIds.begin(); _iter728 != this->fileIds.end(); ++_iter728)
{
- xfer += oprot->writeI64((*_iter729));
+ xfer += oprot->writeI64((*_iter728));
}
xfer += oprot->writeListEnd();
}
@@ -17513,10 +17557,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 _iter730;
- for (_iter730 = this->metadata.begin(); _iter730 != this->metadata.end(); ++_iter730)
+ std::vector<std::string> ::const_iterator _iter729;
+ for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729)
{
- xfer += oprot->writeBinary((*_iter730));
+ xfer += oprot->writeBinary((*_iter729));
}
xfer += oprot->writeListEnd();
}
@@ -17540,17 +17584,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 {
@@ -17611,11 +17655,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 {
@@ -17659,14 +17703,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();
}
@@ -17697,10 +17741,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 _iter740;
- for (_iter740 = this->fileIds.begin(); _iter740 != this->fileIds.end(); ++_iter740)
+ std::vector<int64_t> ::const_iterator _iter739;
+ for (_iter739 = this->fileIds.begin(); _iter739 != this->fileIds.end(); ++_iter739)
{
- xfer += oprot->writeI64((*_iter740));
+ xfer += oprot->writeI64((*_iter739));
}
xfer += oprot->writeListEnd();
}
@@ -17716,11 +17760,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 {
@@ -17802,11 +17846,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 {
@@ -17947,19 +17991,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 {
@@ -18064,13 +18108,13 @@ void swap(GetNextWriteIdRequest &a, GetNextWriteIdRequest &b) {
swap(a.tblName, b.tblName);
}
-GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other747) {
+GetNextWriteIdRequest::GetNextWriteIdRequest(const GetNextWriteIdRequest& other746) {
+ dbName = other746.dbName;
+ tblName = other746.tblName;
+}
+GetNextWriteIdRequest& GetNextWriteIdRequest::operator=(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 {
@@ -18153,11 +18197,11 @@ void swap(GetNextWriteIdResult &a, GetNextWriteIdResult &b) {
swap(a.writeId, b.writeId);
}
-GetNextWriteIdResult::GetNextWriteIdResult(const GetNextWriteIdResult& other749) {
- writeId = other749.writeId;
+GetNextWriteIdResult::
<TRUNCATED>