http://git-wip-us.apache.org/repos/asf/hive/blob/7b24ff74/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 1e1acaa..fca5ae5 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -163,6 +163,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void heartbeat(const HeartbeatRequest& ids) = 0; virtual void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) = 0; virtual void compact(const CompactionRequest& rqst) = 0; + virtual void compact2(CompactionResponse& _return, const CompactionRequest& rqst) = 0; virtual void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) = 0; virtual void add_dynamic_partitions(const AddDynamicPartitions& rqst) = 0; virtual void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0; @@ -654,6 +655,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void compact(const CompactionRequest& /* rqst */) { return; } + void compact2(CompactionResponse& /* _return */, const CompactionRequest& /* rqst */) { + return; + } void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) { return; } @@ -18383,6 +18387,110 @@ class ThriftHiveMetastore_compact_presult { }; +typedef struct _ThriftHiveMetastore_compact2_args__isset { + _ThriftHiveMetastore_compact2_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_compact2_args__isset; + +class ThriftHiveMetastore_compact2_args { + public: + + ThriftHiveMetastore_compact2_args(const ThriftHiveMetastore_compact2_args&); + ThriftHiveMetastore_compact2_args& operator=(const ThriftHiveMetastore_compact2_args&); + ThriftHiveMetastore_compact2_args() { + } + + virtual ~ThriftHiveMetastore_compact2_args() throw(); + CompactionRequest rqst; + + _ThriftHiveMetastore_compact2_args__isset __isset; + + void __set_rqst(const CompactionRequest& val); + + bool operator == (const ThriftHiveMetastore_compact2_args & rhs) const + { + if (!(rqst == rhs.rqst)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_compact2_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact2_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_compact2_pargs { + public: + + + virtual ~ThriftHiveMetastore_compact2_pargs() throw(); + const CompactionRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_compact2_result__isset { + _ThriftHiveMetastore_compact2_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_compact2_result__isset; + +class ThriftHiveMetastore_compact2_result { + public: + + ThriftHiveMetastore_compact2_result(const ThriftHiveMetastore_compact2_result&); + ThriftHiveMetastore_compact2_result& operator=(const ThriftHiveMetastore_compact2_result&); + ThriftHiveMetastore_compact2_result() { + } + + virtual ~ThriftHiveMetastore_compact2_result() throw(); + CompactionResponse success; + + _ThriftHiveMetastore_compact2_result__isset __isset; + + void __set_success(const CompactionResponse& val); + + bool operator == (const ThriftHiveMetastore_compact2_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_compact2_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_compact2_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_compact2_presult__isset { + _ThriftHiveMetastore_compact2_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_compact2_presult__isset; + +class ThriftHiveMetastore_compact2_presult { + public: + + + virtual ~ThriftHiveMetastore_compact2_presult() throw(); + CompactionResponse* success; + + _ThriftHiveMetastore_compact2_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_show_compact_args__isset { _ThriftHiveMetastore_show_compact_args__isset() : rqst(false) {} bool rqst :1; @@ -19927,6 +20035,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void compact(const CompactionRequest& rqst); void send_compact(const CompactionRequest& rqst); void recv_compact(); + void compact2(CompactionResponse& _return, const CompactionRequest& rqst); + void send_compact2(const CompactionRequest& rqst); + void recv_compact2(CompactionResponse& _return); void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst); void send_show_compact(const ShowCompactRequest& rqst); void recv_show_compact(ShowCompactResponse& _return); @@ -20111,6 +20222,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_heartbeat(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_heartbeat_txn_range(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_compact2(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_add_dynamic_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_next_notification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -20267,6 +20379,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["heartbeat"] = &ThriftHiveMetastoreProcessor::process_heartbeat; processMap_["heartbeat_txn_range"] = &ThriftHiveMetastoreProcessor::process_heartbeat_txn_range; processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact; + processMap_["compact2"] = &ThriftHiveMetastoreProcessor::process_compact2; processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact; processMap_["add_dynamic_partitions"] = &ThriftHiveMetastoreProcessor::process_add_dynamic_partitions; processMap_["get_next_notification"] = &ThriftHiveMetastoreProcessor::process_get_next_notification; @@ -21660,6 +21773,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi ifaces_[i]->compact(rqst); } + void compact2(CompactionResponse& _return, const CompactionRequest& rqst) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->compact2(_return, rqst); + } + ifaces_[i]->compact2(_return, rqst); + return; + } + void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) { size_t sz = ifaces_.size(); size_t i = 0; @@ -22207,6 +22330,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void compact(const CompactionRequest& rqst); int32_t send_compact(const CompactionRequest& rqst); void recv_compact(const int32_t seqid); + void compact2(CompactionResponse& _return, const CompactionRequest& rqst); + int32_t send_compact2(const CompactionRequest& rqst); + void recv_compact2(CompactionResponse& _return, const int32_t seqid); void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst); int32_t send_show_compact(const ShowCompactRequest& rqst); void recv_show_compact(ShowCompactResponse& _return, const int32_t seqid);
http://git-wip-us.apache.org/repos/asf/hive/blob/7b24ff74/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index 7a3fa4b..dfa462d 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -727,6 +727,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("compact\n"); } + void compact2(CompactionResponse& _return, const CompactionRequest& rqst) { + // Your implementation goes here + printf("compact2\n"); + } + void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) { // Your implementation goes here printf("show_compact\n"); http://git-wip-us.apache.org/repos/asf/hive/blob/7b24ff74/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 974ddb5..1fae3bc 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -14713,6 +14713,138 @@ void CompactionRequest::printTo(std::ostream& out) const { } +CompactionResponse::~CompactionResponse() throw() { +} + + +void CompactionResponse::__set_id(const int64_t val) { + this->id = val; +} + +void CompactionResponse::__set_state(const std::string& val) { + this->state = val; +} + +void CompactionResponse::__set_accepted(const bool val) { + this->accepted = val; +} + +uint32_t CompactionResponse::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + bool isset_id = false; + bool isset_state = false; + bool isset_accepted = false; + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + isset_id = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->state); + isset_state = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->accepted); + isset_accepted = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_id) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_state) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_accepted) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t CompactionResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CompactionResponse"); + + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->state); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("accepted", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->accepted); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CompactionResponse &a, CompactionResponse &b) { + using ::std::swap; + swap(a.id, b.id); + swap(a.state, b.state); + swap(a.accepted, b.accepted); +} + +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 { + using ::apache::thrift::to_string; + out << "CompactionResponse("; + out << "id=" << to_string(id); + out << ", " << "state=" << to_string(state); + out << ", " << "accepted=" << to_string(accepted); + out << ")"; +} + + ShowCompactRequest::~ShowCompactRequest() throw() { } @@ -14761,11 +14893,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other613) { - (void) other613; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other615) { + (void) other615; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other614) { - (void) other614; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other616) { + (void) other616; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -14835,6 +14967,11 @@ void ShowCompactResponseElement::__set_hadoopJobId(const std::string& val) { __isset.hadoopJobId = true; } +void ShowCompactResponseElement::__set_id(const int64_t val) { + this->id = val; +__isset.id = true; +} + uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -14886,9 +15023,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast615; - xfer += iprot->readI32(ecast615); - this->type = (CompactionType::type)ecast615; + int32_t ecast617; + xfer += iprot->readI32(ecast617); + this->type = (CompactionType::type)ecast617; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14958,6 +15095,14 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* xfer += iprot->skip(ftype); } break; + case 13: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->id); + this->__isset.id = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -15039,6 +15184,11 @@ uint32_t ShowCompactResponseElement::write(::apache::thrift::protocol::TProtocol xfer += oprot->writeString(this->hadoopJobId); xfer += oprot->writeFieldEnd(); } + if (this->__isset.id) { + xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 13); + xfer += oprot->writeI64(this->id); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -15058,38 +15208,41 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.metaInfo, b.metaInfo); swap(a.endTime, b.endTime); swap(a.hadoopJobId, b.hadoopJobId); + swap(a.id, b.id); swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other616) { - dbname = other616.dbname; - tablename = other616.tablename; - partitionname = other616.partitionname; - type = other616.type; - state = other616.state; - workerid = other616.workerid; - start = other616.start; - runAs = other616.runAs; - hightestTxnId = other616.hightestTxnId; - metaInfo = other616.metaInfo; - endTime = other616.endTime; - hadoopJobId = other616.hadoopJobId; - __isset = other616.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(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; - __isset = other617.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other618) { + dbname = other618.dbname; + tablename = other618.tablename; + partitionname = other618.partitionname; + type = other618.type; + state = other618.state; + workerid = other618.workerid; + start = other618.start; + runAs = other618.runAs; + hightestTxnId = other618.hightestTxnId; + metaInfo = other618.metaInfo; + endTime = other618.endTime; + 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 { @@ -15107,6 +15260,7 @@ void ShowCompactResponseElement::printTo(std::ostream& out) const { out << ", " << "metaInfo="; (__isset.metaInfo ? (out << to_string(metaInfo)) : (out << "<null>")); out << ", " << "endTime="; (__isset.endTime ? (out << to_string(endTime)) : (out << "<null>")); out << ", " << "hadoopJobId="; (__isset.hadoopJobId ? (out << to_string(hadoopJobId)) : (out << "<null>")); + out << ", " << "id="; (__isset.id ? (out << to_string(id)) : (out << "<null>")); out << ")"; } @@ -15145,14 +15299,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size618; - ::apache::thrift::protocol::TType _etype621; - xfer += iprot->readListBegin(_etype621, _size618); - this->compacts.resize(_size618); - uint32_t _i622; - for (_i622 = 0; _i622 < _size618; ++_i622) + 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[_i622].read(iprot); + xfer += this->compacts[_i624].read(iprot); } xfer += iprot->readListEnd(); } @@ -15183,10 +15337,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 _iter623; - for (_iter623 = this->compacts.begin(); _iter623 != this->compacts.end(); ++_iter623) + std::vector<ShowCompactResponseElement> ::const_iterator _iter625; + for (_iter625 = this->compacts.begin(); _iter625 != this->compacts.end(); ++_iter625) { - xfer += (*_iter623).write(oprot); + xfer += (*_iter625).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15202,11 +15356,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other624) { - compacts = other624.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other626) { + compacts = other626.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other625) { - compacts = other625.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other627) { + compacts = other627.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -15295,14 +15449,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size626; - ::apache::thrift::protocol::TType _etype629; - xfer += iprot->readListBegin(_etype629, _size626); - this->partitionnames.resize(_size626); - uint32_t _i630; - for (_i630 = 0; _i630 < _size626; ++_i630) + 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[_i630]); + xfer += iprot->readString(this->partitionnames[_i632]); } xfer += iprot->readListEnd(); } @@ -15313,9 +15467,9 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast631; - xfer += iprot->readI32(ecast631); - this->operationType = (DataOperationType::type)ecast631; + int32_t ecast633; + xfer += iprot->readI32(ecast633); + this->operationType = (DataOperationType::type)ecast633; this->__isset.operationType = true; } else { xfer += iprot->skip(ftype); @@ -15361,10 +15515,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 _iter632; - for (_iter632 = this->partitionnames.begin(); _iter632 != this->partitionnames.end(); ++_iter632) + std::vector<std::string> ::const_iterator _iter634; + for (_iter634 = this->partitionnames.begin(); _iter634 != this->partitionnames.end(); ++_iter634) { - xfer += oprot->writeString((*_iter632)); + xfer += oprot->writeString((*_iter634)); } xfer += oprot->writeListEnd(); } @@ -15390,21 +15544,21 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.__isset, b.__isset); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other633) { - txnid = other633.txnid; - dbname = other633.dbname; - tablename = other633.tablename; - partitionnames = other633.partitionnames; - operationType = other633.operationType; - __isset = other633.__isset; -} -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other634) { - txnid = other634.txnid; - dbname = other634.dbname; - tablename = other634.tablename; - partitionnames = other634.partitionnames; - operationType = other634.operationType; - __isset = other634.__isset; +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 { @@ -15510,15 +15664,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other635) { - lastEvent = other635.lastEvent; - maxEvents = other635.maxEvents; - __isset = other635.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other637) { + lastEvent = other637.lastEvent; + maxEvents = other637.maxEvents; + __isset = other637.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other636) { - lastEvent = other636.lastEvent; - maxEvents = other636.maxEvents; - __isset = other636.__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 { @@ -15700,23 +15854,23 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other637) { - eventId = other637.eventId; - eventTime = other637.eventTime; - eventType = other637.eventType; - dbName = other637.dbName; - tableName = other637.tableName; - message = other637.message; - __isset = other637.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other638) { - eventId = other638.eventId; - eventTime = other638.eventTime; - eventType = other638.eventType; - dbName = other638.dbName; - tableName = other638.tableName; - message = other638.message; - __isset = other638.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other639) { + eventId = other639.eventId; + eventTime = other639.eventTime; + eventType = other639.eventType; + dbName = other639.dbName; + tableName = other639.tableName; + message = other639.message; + __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; + __isset = other640.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15766,14 +15920,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size639; - ::apache::thrift::protocol::TType _etype642; - xfer += iprot->readListBegin(_etype642, _size639); - this->events.resize(_size639); - uint32_t _i643; - for (_i643 = 0; _i643 < _size639; ++_i643) + 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[_i643].read(iprot); + xfer += this->events[_i645].read(iprot); } xfer += iprot->readListEnd(); } @@ -15804,10 +15958,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 _iter644; - for (_iter644 = this->events.begin(); _iter644 != this->events.end(); ++_iter644) + std::vector<NotificationEvent> ::const_iterator _iter646; + for (_iter646 = this->events.begin(); _iter646 != this->events.end(); ++_iter646) { - xfer += (*_iter644).write(oprot); + xfer += (*_iter646).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15823,11 +15977,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other645) { - events = other645.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other647) { + events = other647.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other646) { - events = other646.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other648) { + events = other648.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -15909,11 +16063,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other647) { - eventId = other647.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other649) { + eventId = other649.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other648) { - eventId = other648.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other650) { + eventId = other650.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -15958,14 +16112,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->filesAdded.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + 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[_i653]); + xfer += iprot->readString(this->filesAdded[_i655]); } xfer += iprot->readListEnd(); } @@ -15996,10 +16150,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op 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 _iter654; - for (_iter654 = this->filesAdded.begin(); _iter654 != this->filesAdded.end(); ++_iter654) + std::vector<std::string> ::const_iterator _iter656; + for (_iter656 = this->filesAdded.begin(); _iter656 != this->filesAdded.end(); ++_iter656) { - xfer += oprot->writeString((*_iter654)); + xfer += oprot->writeString((*_iter656)); } xfer += oprot->writeListEnd(); } @@ -16015,11 +16169,11 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.filesAdded, b.filesAdded); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other655) { - filesAdded = other655.filesAdded; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other657) { + filesAdded = other657.filesAdded; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other656) { - filesAdded = other656.filesAdded; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other658) { + filesAdded = other658.filesAdded; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -16099,13 +16253,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other657) { - insertData = other657.insertData; - __isset = other657.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other659) { + insertData = other659.insertData; + __isset = other659.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other658) { - insertData = other658.insertData; - __isset = other658.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other660) { + insertData = other660.insertData; + __isset = other660.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -16202,14 +16356,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size659; - ::apache::thrift::protocol::TType _etype662; - xfer += iprot->readListBegin(_etype662, _size659); - this->partitionVals.resize(_size659); - uint32_t _i663; - for (_i663 = 0; _i663 < _size659; ++_i663) + uint32_t _size661; + ::apache::thrift::protocol::TType _etype664; + xfer += iprot->readListBegin(_etype664, _size661); + this->partitionVals.resize(_size661); + uint32_t _i665; + for (_i665 = 0; _i665 < _size661; ++_i665) { - xfer += iprot->readString(this->partitionVals[_i663]); + xfer += iprot->readString(this->partitionVals[_i665]); } xfer += iprot->readListEnd(); } @@ -16261,10 +16415,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 _iter664; - for (_iter664 = this->partitionVals.begin(); _iter664 != this->partitionVals.end(); ++_iter664) + std::vector<std::string> ::const_iterator _iter666; + for (_iter666 = this->partitionVals.begin(); _iter666 != this->partitionVals.end(); ++_iter666) { - xfer += oprot->writeString((*_iter664)); + xfer += oprot->writeString((*_iter666)); } xfer += oprot->writeListEnd(); } @@ -16285,21 +16439,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other665) { - successful = other665.successful; - data = other665.data; - dbName = other665.dbName; - tableName = other665.tableName; - partitionVals = other665.partitionVals; - __isset = other665.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other666) { - successful = other666.successful; - data = other666.data; - dbName = other666.dbName; - tableName = other666.tableName; - partitionVals = other666.partitionVals; - __isset = other666.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other667) { + successful = other667.successful; + data = other667.data; + dbName = other667.dbName; + tableName = other667.tableName; + partitionVals = other667.partitionVals; + __isset = other667.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other668) { + successful = other668.successful; + data = other668.data; + dbName = other668.dbName; + tableName = other668.tableName; + partitionVals = other668.partitionVals; + __isset = other668.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -16362,11 +16516,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other667) { - (void) other667; +FireEventResponse::FireEventResponse(const FireEventResponse& other669) { + (void) other669; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other668) { - (void) other668; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other670) { + (void) other670; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -16466,15 +16620,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other669) { - metadata = other669.metadata; - includeBitset = other669.includeBitset; - __isset = other669.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other671) { + metadata = other671.metadata; + includeBitset = other671.includeBitset; + __isset = other671.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other670) { - metadata = other670.metadata; - includeBitset = other670.includeBitset; - __isset = other670.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other672) { + metadata = other672.metadata; + includeBitset = other672.includeBitset; + __isset = other672.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -16525,17 +16679,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size671; - ::apache::thrift::protocol::TType _ktype672; - ::apache::thrift::protocol::TType _vtype673; - xfer += iprot->readMapBegin(_ktype672, _vtype673, _size671); - uint32_t _i675; - for (_i675 = 0; _i675 < _size671; ++_i675) + uint32_t _size673; + ::apache::thrift::protocol::TType _ktype674; + ::apache::thrift::protocol::TType _vtype675; + xfer += iprot->readMapBegin(_ktype674, _vtype675, _size673); + uint32_t _i677; + for (_i677 = 0; _i677 < _size673; ++_i677) { - int64_t _key676; - xfer += iprot->readI64(_key676); - MetadataPpdResult& _val677 = this->metadata[_key676]; - xfer += _val677.read(iprot); + int64_t _key678; + xfer += iprot->readI64(_key678); + MetadataPpdResult& _val679 = this->metadata[_key678]; + xfer += _val679.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16576,11 +16730,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 _iter678; - for (_iter678 = this->metadata.begin(); _iter678 != this->metadata.end(); ++_iter678) + std::map<int64_t, MetadataPpdResult> ::const_iterator _iter680; + for (_iter680 = this->metadata.begin(); _iter680 != this->metadata.end(); ++_iter680) { - xfer += oprot->writeI64(_iter678->first); - xfer += _iter678->second.write(oprot); + xfer += oprot->writeI64(_iter680->first); + xfer += _iter680->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16601,13 +16755,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other679) { - metadata = other679.metadata; - isSupported = other679.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other681) { + metadata = other681.metadata; + isSupported = other681.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other680) { - metadata = other680.metadata; - isSupported = other680.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other682) { + metadata = other682.metadata; + isSupported = other682.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16668,14 +16822,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size681; - ::apache::thrift::protocol::TType _etype684; - xfer += iprot->readListBegin(_etype684, _size681); - this->fileIds.resize(_size681); - uint32_t _i685; - for (_i685 = 0; _i685 < _size681; ++_i685) + uint32_t _size683; + ::apache::thrift::protocol::TType _etype686; + xfer += iprot->readListBegin(_etype686, _size683); + this->fileIds.resize(_size683); + uint32_t _i687; + for (_i687 = 0; _i687 < _size683; ++_i687) { - xfer += iprot->readI64(this->fileIds[_i685]); + xfer += iprot->readI64(this->fileIds[_i687]); } xfer += iprot->readListEnd(); } @@ -16702,9 +16856,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast686; - xfer += iprot->readI32(ecast686); - this->type = (FileMetadataExprType::type)ecast686; + int32_t ecast688; + xfer += iprot->readI32(ecast688); + this->type = (FileMetadataExprType::type)ecast688; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16734,10 +16888,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 _iter687; - for (_iter687 = this->fileIds.begin(); _iter687 != this->fileIds.end(); ++_iter687) + std::vector<int64_t> ::const_iterator _iter689; + for (_iter689 = this->fileIds.begin(); _iter689 != this->fileIds.end(); ++_iter689) { - xfer += oprot->writeI64((*_iter687)); + xfer += oprot->writeI64((*_iter689)); } xfer += oprot->writeListEnd(); } @@ -16771,19 +16925,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other688) { - fileIds = other688.fileIds; - expr = other688.expr; - doGetFooters = other688.doGetFooters; - type = other688.type; - __isset = other688.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other690) { + fileIds = other690.fileIds; + expr = other690.expr; + doGetFooters = other690.doGetFooters; + type = other690.type; + __isset = other690.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other689) { - fileIds = other689.fileIds; - expr = other689.expr; - doGetFooters = other689.doGetFooters; - type = other689.type; - __isset = other689.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other691) { + fileIds = other691.fileIds; + expr = other691.expr; + doGetFooters = other691.doGetFooters; + type = other691.type; + __isset = other691.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -16836,17 +16990,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _ktype691; - ::apache::thrift::protocol::TType _vtype692; - xfer += iprot->readMapBegin(_ktype691, _vtype692, _size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size692; + ::apache::thrift::protocol::TType _ktype693; + ::apache::thrift::protocol::TType _vtype694; + xfer += iprot->readMapBegin(_ktype693, _vtype694, _size692); + uint32_t _i696; + for (_i696 = 0; _i696 < _size692; ++_i696) { - int64_t _key695; - xfer += iprot->readI64(_key695); - std::string& _val696 = this->metadata[_key695]; - xfer += iprot->readBinary(_val696); + int64_t _key697; + xfer += iprot->readI64(_key697); + std::string& _val698 = this->metadata[_key697]; + xfer += iprot->readBinary(_val698); } xfer += iprot->readMapEnd(); } @@ -16887,11 +17041,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 _iter697; - for (_iter697 = this->metadata.begin(); _iter697 != this->metadata.end(); ++_iter697) + std::map<int64_t, std::string> ::const_iterator _iter699; + for (_iter699 = this->metadata.begin(); _iter699 != this->metadata.end(); ++_iter699) { - xfer += oprot->writeI64(_iter697->first); - xfer += oprot->writeBinary(_iter697->second); + xfer += oprot->writeI64(_iter699->first); + xfer += oprot->writeBinary(_iter699->second); } xfer += oprot->writeMapEnd(); } @@ -16912,13 +17066,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other698) { - metadata = other698.metadata; - isSupported = other698.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other700) { + metadata = other700.metadata; + isSupported = other700.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other699) { - metadata = other699.metadata; - isSupported = other699.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other701) { + metadata = other701.metadata; + isSupported = other701.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -16964,14 +17118,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size700; - ::apache::thrift::protocol::TType _etype703; - xfer += iprot->readListBegin(_etype703, _size700); - this->fileIds.resize(_size700); - uint32_t _i704; - for (_i704 = 0; _i704 < _size700; ++_i704) + uint32_t _size702; + ::apache::thrift::protocol::TType _etype705; + xfer += iprot->readListBegin(_etype705, _size702); + this->fileIds.resize(_size702); + uint32_t _i706; + for (_i706 = 0; _i706 < _size702; ++_i706) { - xfer += iprot->readI64(this->fileIds[_i704]); + xfer += iprot->readI64(this->fileIds[_i706]); } xfer += iprot->readListEnd(); } @@ -17002,10 +17156,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 _iter705; - for (_iter705 = this->fileIds.begin(); _iter705 != this->fileIds.end(); ++_iter705) + std::vector<int64_t> ::const_iterator _iter707; + for (_iter707 = this->fileIds.begin(); _iter707 != this->fileIds.end(); ++_iter707) { - xfer += oprot->writeI64((*_iter705)); + xfer += oprot->writeI64((*_iter707)); } xfer += oprot->writeListEnd(); } @@ -17021,11 +17175,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other706) { - fileIds = other706.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other708) { + fileIds = other708.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other707) { - fileIds = other707.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other709) { + fileIds = other709.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -17084,11 +17238,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other708) { - (void) other708; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other710) { + (void) other710; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other709) { - (void) other709; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other711) { + (void) other711; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -17142,14 +17296,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size710; - ::apache::thrift::protocol::TType _etype713; - xfer += iprot->readListBegin(_etype713, _size710); - this->fileIds.resize(_size710); - uint32_t _i714; - for (_i714 = 0; _i714 < _size710; ++_i714) + uint32_t _size712; + ::apache::thrift::protocol::TType _etype715; + xfer += iprot->readListBegin(_etype715, _size712); + this->fileIds.resize(_size712); + uint32_t _i716; + for (_i716 = 0; _i716 < _size712; ++_i716) { - xfer += iprot->readI64(this->fileIds[_i714]); + xfer += iprot->readI64(this->fileIds[_i716]); } xfer += iprot->readListEnd(); } @@ -17162,14 +17316,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size715; - ::apache::thrift::protocol::TType _etype718; - xfer += iprot->readListBegin(_etype718, _size715); - this->metadata.resize(_size715); - uint32_t _i719; - for (_i719 = 0; _i719 < _size715; ++_i719) + uint32_t _size717; + ::apache::thrift::protocol::TType _etype720; + xfer += iprot->readListBegin(_etype720, _size717); + this->metadata.resize(_size717); + uint32_t _i721; + for (_i721 = 0; _i721 < _size717; ++_i721) { - xfer += iprot->readBinary(this->metadata[_i719]); + xfer += iprot->readBinary(this->metadata[_i721]); } xfer += iprot->readListEnd(); } @@ -17180,9 +17334,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast720; - xfer += iprot->readI32(ecast720); - this->type = (FileMetadataExprType::type)ecast720; + int32_t ecast722; + xfer += iprot->readI32(ecast722); + this->type = (FileMetadataExprType::type)ecast722; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -17212,10 +17366,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 _iter721; - for (_iter721 = this->fileIds.begin(); _iter721 != this->fileIds.end(); ++_iter721) + std::vector<int64_t> ::const_iterator _iter723; + for (_iter723 = this->fileIds.begin(); _iter723 != this->fileIds.end(); ++_iter723) { - xfer += oprot->writeI64((*_iter721)); + xfer += oprot->writeI64((*_iter723)); } xfer += oprot->writeListEnd(); } @@ -17224,10 +17378,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 _iter722; - for (_iter722 = this->metadata.begin(); _iter722 != this->metadata.end(); ++_iter722) + std::vector<std::string> ::const_iterator _iter724; + for (_iter724 = this->metadata.begin(); _iter724 != this->metadata.end(); ++_iter724) { - xfer += oprot->writeBinary((*_iter722)); + xfer += oprot->writeBinary((*_iter724)); } xfer += oprot->writeListEnd(); } @@ -17251,17 +17405,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other723) { - fileIds = other723.fileIds; - metadata = other723.metadata; - type = other723.type; - __isset = other723.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other725) { + fileIds = other725.fileIds; + metadata = other725.metadata; + type = other725.type; + __isset = other725.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other724) { - fileIds = other724.fileIds; - metadata = other724.metadata; - type = other724.type; - __isset = other724.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other726) { + fileIds = other726.fileIds; + metadata = other726.metadata; + type = other726.type; + __isset = other726.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -17322,11 +17476,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other725) { - (void) other725; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other727) { + (void) other727; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other726) { - (void) other726; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other728) { + (void) other728; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -17370,14 +17524,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size727; - ::apache::thrift::protocol::TType _etype730; - xfer += iprot->readListBegin(_etype730, _size727); - this->fileIds.resize(_size727); - uint32_t _i731; - for (_i731 = 0; _i731 < _size727; ++_i731) + uint32_t _size729; + ::apache::thrift::protocol::TType _etype732; + xfer += iprot->readListBegin(_etype732, _size729); + this->fileIds.resize(_size729); + uint32_t _i733; + for (_i733 = 0; _i733 < _size729; ++_i733) { - xfer += iprot->readI64(this->fileIds[_i731]); + xfer += iprot->readI64(this->fileIds[_i733]); } xfer += iprot->readListEnd(); } @@ -17408,10 +17562,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 _iter732; - for (_iter732 = this->fileIds.begin(); _iter732 != this->fileIds.end(); ++_iter732) + std::vector<int64_t> ::const_iterator _iter734; + for (_iter734 = this->fileIds.begin(); _iter734 != this->fileIds.end(); ++_iter734) { - xfer += oprot->writeI64((*_iter732)); + xfer += oprot->writeI64((*_iter734)); } xfer += oprot->writeListEnd(); } @@ -17427,11 +17581,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other733) { - fileIds = other733.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other735) { + fileIds = other735.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other734) { - fileIds = other734.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other736) { + fileIds = other736.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -17513,11 +17667,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other735) { - isSupported = other735.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other737) { + isSupported = other737.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other736) { - isSupported = other736.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other738) { + isSupported = other738.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17658,19 +17812,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other737) { - dbName = other737.dbName; - tblName = other737.tblName; - partName = other737.partName; - isAllParts = other737.isAllParts; - __isset = other737.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other739) { + dbName = other739.dbName; + tblName = other739.tblName; + partName = other739.partName; + isAllParts = other739.isAllParts; + __isset = other739.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other738) { - dbName = other738.dbName; - tblName = other738.tblName; - partName = other738.partName; - isAllParts = other738.isAllParts; - __isset = other738.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other740) { + dbName = other740.dbName; + tblName = other740.tblName; + partName = other740.partName; + isAllParts = other740.isAllParts; + __isset = other740.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17718,14 +17872,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size739; - ::apache::thrift::protocol::TType _etype742; - xfer += iprot->readListBegin(_etype742, _size739); - this->functions.resize(_size739); - uint32_t _i743; - for (_i743 = 0; _i743 < _size739; ++_i743) + uint32_t _size741; + ::apache::thrift::protocol::TType _etype744; + xfer += iprot->readListBegin(_etype744, _size741); + this->functions.resize(_size741); + uint32_t _i745; + for (_i745 = 0; _i745 < _size741; ++_i745) { - xfer += this->functions[_i743].read(iprot); + xfer += this->functions[_i745].read(iprot); } xfer += iprot->readListEnd(); } @@ -17755,10 +17909,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size())); - std::vector<Function> ::const_iterator _iter744; - for (_iter744 = this->functions.begin(); _iter744 != this->functions.end(); ++_iter744) + std::vector<Function> ::const_iterator _iter746; + for (_iter746 = this->functions.begin(); _iter746 != this->functions.end(); ++_iter746) { - xfer += (*_iter744).write(oprot); + xfer += (*_iter746).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17775,13 +17929,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other745) { - functions = other745.functions; - __isset = other745.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other747) { + functions = other747.functions; + __isset = other747.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other746) { - functions = other746.functions; - __isset = other746.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other748) { + functions = other748.functions; + __isset = other748.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -17826,16 +17980,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - this->values.resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size749; + ::apache::thrift::protocol::TType _etype752; + xfer += iprot->readListBegin(_etype752, _size749); + this->values.resize(_size749); + uint32_t _i753; + for (_i753 = 0; _i753 < _size749; ++_i753) { - int32_t ecast752; - xfer += iprot->readI32(ecast752); - this->values[_i751] = (ClientCapability::type)ecast752; + int32_t ecast754; + xfer += iprot->readI32(ecast754); + this->values[_i753] = (ClientCapability::type)ecast754; } xfer += iprot->readListEnd(); } @@ -17866,10 +18020,10 @@ uint32_t ClientCapabilities::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size())); - std::vector<ClientCapability::type> ::const_iterator _iter753; - for (_iter753 = this->values.begin(); _iter753 != this->values.end(); ++_iter753) + std::vector<ClientCapability::type> ::const_iterator _iter755; + for (_iter755 = this->values.begin(); _iter755 != this->values.end(); ++_iter755) { - xfer += oprot->writeI32((int32_t)(*_iter753)); + xfer += oprot->writeI32((int32_t)(*_iter755)); } xfer += oprot->writeListEnd(); } @@ -17885,11 +18039,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other754) { - values = other754.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other756) { + values = other756.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other755) { - values = other755.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other757) { + values = other757.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -18011,17 +18165,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other756) { - dbName = other756.dbName; - tblName = other756.tblName; - capabilities = other756.capabilities; - __isset = other756.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other758) { + dbName = other758.dbName; + tblName = other758.tblName; + capabilities = other758.capabilities; + __isset = other758.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other757) { - dbName = other757.dbName; - tblName = other757.tblName; - capabilities = other757.capabilities; - __isset = other757.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other759) { + dbName = other759.dbName; + tblName = other759.tblName; + capabilities = other759.capabilities; + __isset = other759.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -18105,11 +18259,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other758) { - table = other758.table; +GetTableResult::GetTableResult(const GetTableResult& other760) { + table = other760.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other759) { - table = other759.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other761) { + table = other761.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -18172,14 +18326,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size760; - ::apache::thrift::protocol::TType _etype763; - xfer += iprot->readListBegin(_etype763, _size760); - this->tblNames.resize(_size760); - uint32_t _i764; - for (_i764 = 0; _i764 < _size760; ++_i764) + uint32_t _size762; + ::apache::thrift::protocol::TType _etype765; + xfer += iprot->readListBegin(_etype765, _size762); + this->tblNames.resize(_size762); + uint32_t _i766; + for (_i766 = 0; _i766 < _size762; ++_i766) { - xfer += iprot->readString(this->tblNames[_i764]); + xfer += iprot->readString(this->tblNames[_i766]); } xfer += iprot->readListEnd(); } @@ -18223,10 +18377,10 @@ uint32_t GetTablesRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tblNames", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tblNames.size())); - std::vector<std::string> ::const_iterator _iter765; - for (_iter765 = this->tblNames.begin(); _iter765 != this->tblNames.end(); ++_iter765) + std::vector<std::string> ::const_iterator _iter767; + for (_iter767 = this->tblNames.begin(); _iter767 != this->tblNames.end(); ++_iter767) { - xfer += oprot->writeString((*_iter765)); + xfer += oprot->writeString((*_iter767)); } xfer += oprot->writeListEnd(); } @@ -18250,17 +18404,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other766) { - dbName = other766.dbName; - tblNames = other766.tblNames; - capabilities = other766.capabilities; - __isset = other766.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other768) { + dbName = other768.dbName; + tblNames = other768.tblNames; + capabilities = other768.capabilities; + __isset = other768.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other767) { - dbName = other767.dbName; - tblNames = other767.tblNames; - capabilities = other767.capabilities; - __isset = other767.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other769) { + dbName = other769.dbName; + tblNames = other769.tblNames; + capabilities = other769.capabilities; + __isset = other769.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -18307,14 +18461,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size768; - ::apache::thrift::protocol::TType _etype771; - xfer += iprot->readListBegin(_etype771, _size768); - this->tables.resize(_size768); - uint32_t _i772; - for (_i772 = 0; _i772 < _size768; ++_i772) + uint32_t _size770; + ::apache::thrift::protocol::TType _etype773; + xfer += iprot->readListBegin(_etype773, _size770); + this->tables.resize(_size770); + uint32_t _i774; + for (_i774 = 0; _i774 < _size770; ++_i774) { - xfer += this->tables[_i772].read(iprot); + xfer += this->tables[_i774].read(iprot); } xfer += iprot->readListEnd(); } @@ -18345,10 +18499,10 @@ uint32_t GetTablesResult::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tables.size())); - std::vector<Table> ::const_iterator _iter773; - for (_iter773 = this->tables.begin(); _iter773 != this->tables.end(); ++_iter773) + std::vector<Table> ::const_iterator _iter775; + for (_iter775 = this->tables.begin(); _iter775 != this->tables.end(); ++_iter775) { - xfer += (*_iter773).write(oprot); + xfer += (*_iter775).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18364,11 +18518,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other774) { - tables = other774.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other776) { + tables = other776.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other775) { - tables = other775.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other777) { + tables = other777.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -18510,19 +18664,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other776) { - dbName = other776.dbName; - tableName = other776.tableName; - tableType = other776.tableType; - comments = other776.comments; - __isset = other776.__isset; +TableMeta::TableMeta(const TableMeta& other778) { + dbName = other778.dbName; + tableName = other778.tableName; + tableType = other778.tableType; + comments = other778.comments; + __isset = other778.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other777) { - dbName = other777.dbName; - tableName = other777.tableName; - tableType = other777.tableType; - comments = other777.comments; - __isset = other777.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other779) { + dbName = other779.dbName; + tableName = other779.tableName; + tableType = other779.tableType; + comments = other779.comments; + __isset = other779.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -18605,13 +18759,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other778) : TException() { - message = other778.message; - __isset = other778.__isset; +MetaException::MetaException(const MetaException& other780) : TException() { + message = other780.message; + __isset = other780.__isset; } -MetaException& MetaException::operator=(const MetaException& other779) { - message = other779.message; - __isset = other779.__isset; +MetaException& MetaException::operator=(const MetaException& other781) { + message = other781.message; + __isset = other781.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -18702,13 +18856,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other780) : TException() { - message = other780.message; - __isset = other780.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other782) : TException() { + message = other782.message; + __isset = other782.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other781) { - message = other781.message; - __isset = other781.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other783) { + message = other783.message; + __isset = other783.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -18799,13 +18953,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other782) : TException() { - message = other782.message; - __isset = other782.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other784) : TException() { + message = other784.message; + __isset = other784.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other783) { - message = other783.message; - __isset = other783.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other785) { + message = other785.message; + __isset = other785.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -18896,13 +19050,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other784) : TException() { - message = other784.message; - __isset = other784.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other786) : TException() { + message = other786.message; + __isset = other786.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other785) { - message = other785.message; - __isset = other785.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other787) { + message = other787.message; + __isset = other787.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -18993,13 +19147,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other786) : TException() { - message = other786.message; - __isset = other786.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other788) : TException() { + message = other788.message; + __isset = other788.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other787) { - message = other787.message; - __isset = other787.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other789) { + message = other789.message; + __isset = other789.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -19090,13 +19244,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other788) : TException() { - message = other788.message; - __isset = other788.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other790) : TException() { + message = other790.message; + __isset = other790.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other789) { - message = other789.message; - __isset = other789.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other791) { + message = other791.message; + __isset = other791.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -19187,13 +19341,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other790) : TException() { - message = other790.message; - __isset = other790.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other792) : TException() { + message = other792.message; + __isset = other792.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other791) { - message = other791.message; - __isset = other791.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other793) { + message = other793.message; + __isset = other793.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -19284,13 +19438,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other792) : TException() { - message = other792.message; - __isset = other792.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other794) : TException() { + message = other794.message; + __isset = other794.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other793) { - message = other793.message; - __isset = other793.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other795) { + message = other795.message; + __isset = other795.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -19381,13 +19535,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other794) : TException() { - message = other794.message; - __isset = other794.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other796) : TException() { + message = other796.message; + __isset = other796.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other795) { - message = other795.message; - __isset = other795.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other797) { + message = other797.message; + __isset = other797.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -19478,13 +19632,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other796) : TException() { - message = other796.message; - __isset = other796.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other798) : TException() { + message = other798.message; + __isset = other798.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other797) { - message = other797.message; - __isset = other797.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other799) { + message = other799.message; + __isset = other799.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -19575,13 +19729,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other798) : TException() { - message = other798.message; - __isset = other798.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other800) : TException() { + message = other800.message; + __isset = other800.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other799) { - message = other799.message; - __isset = other799.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other801) { + message = other801.message; + __isset = other801.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -19672,13 +19826,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other800) : TException() { - message = other800.message; - __isset = other800.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other802) : TException() { + message = other802.message; + __isset = other802.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other801) { - message = other801.message; - __isset = other801.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other803) { + message = other803.message; + __isset = other803.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -19769,13 +19923,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other802) : TException() { - message = other802.message; - __isset = other802.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other804) : TException() { + message = other804.message; + __isset = other804.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other803) { - message = other803.message; - __isset = other803.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other805) { + message = other805.message; + __isset = other805.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -19866,13 +20020,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other804) : TException() { - message = other804.message; - __isset = other804.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other806) : TException() { + message = other806.message; + __isset = other806.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other805) { - message = other805.message; - __isset = other805.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other807) { + message = other807.message; + __isset = other807.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -19963,13 +20117,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other806) : TException() { - message = other806.message; - __isset = other806.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other808) : TException() { + message = other808.message; + __isset = other808.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other807) { - message = other807.message; - __isset = other807.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other809) { + message = other809.message; + __isset = other809.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -20060,13 +20214,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other808) : TException() { - message = other808.message; - __isset = other808.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other810) : TException() { + message = other810.message; + __isset = other810.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other809) { - message = other809.message; - __isset = other809.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other811) { + message = other811.message; + __isset = other811.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const {