http://git-wip-us.apache.org/repos/asf/hive/blob/70cb7f0b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 8406b42..3094394 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -173,6 +173,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void add_dynamic_partitions(const AddDynamicPartitions& rqst) = 0; virtual void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0; virtual void get_current_notificationEventId(CurrentNotificationEventId& _return) = 0; + virtual void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) = 0; virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) = 0; virtual void flushCache() = 0; virtual void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) = 0; @@ -692,6 +693,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p void get_current_notificationEventId(CurrentNotificationEventId& /* _return */) { return; } + void get_notification_events_count(NotificationEventsCountResponse& /* _return */, const NotificationEventsCountRequest& /* rqst */) { + return; + } void fire_listener_event(FireEventResponse& /* _return */, const FireEventRequest& /* rqst */) { return; } @@ -19527,6 +19531,110 @@ class ThriftHiveMetastore_get_current_notificationEventId_presult { }; +typedef struct _ThriftHiveMetastore_get_notification_events_count_args__isset { + _ThriftHiveMetastore_get_notification_events_count_args__isset() : rqst(false) {} + bool rqst :1; +} _ThriftHiveMetastore_get_notification_events_count_args__isset; + +class ThriftHiveMetastore_get_notification_events_count_args { + public: + + ThriftHiveMetastore_get_notification_events_count_args(const ThriftHiveMetastore_get_notification_events_count_args&); + ThriftHiveMetastore_get_notification_events_count_args& operator=(const ThriftHiveMetastore_get_notification_events_count_args&); + ThriftHiveMetastore_get_notification_events_count_args() { + } + + virtual ~ThriftHiveMetastore_get_notification_events_count_args() throw(); + NotificationEventsCountRequest rqst; + + _ThriftHiveMetastore_get_notification_events_count_args__isset __isset; + + void __set_rqst(const NotificationEventsCountRequest& val); + + bool operator == (const ThriftHiveMetastore_get_notification_events_count_args & rhs) const + { + if (!(rqst == rhs.rqst)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_notification_events_count_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_notification_events_count_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_notification_events_count_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_notification_events_count_pargs() throw(); + const NotificationEventsCountRequest* rqst; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_notification_events_count_result__isset { + _ThriftHiveMetastore_get_notification_events_count_result__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_notification_events_count_result__isset; + +class ThriftHiveMetastore_get_notification_events_count_result { + public: + + ThriftHiveMetastore_get_notification_events_count_result(const ThriftHiveMetastore_get_notification_events_count_result&); + ThriftHiveMetastore_get_notification_events_count_result& operator=(const ThriftHiveMetastore_get_notification_events_count_result&); + ThriftHiveMetastore_get_notification_events_count_result() { + } + + virtual ~ThriftHiveMetastore_get_notification_events_count_result() throw(); + NotificationEventsCountResponse success; + + _ThriftHiveMetastore_get_notification_events_count_result__isset __isset; + + void __set_success(const NotificationEventsCountResponse& val); + + bool operator == (const ThriftHiveMetastore_get_notification_events_count_result & rhs) const + { + if (!(success == rhs.success)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_notification_events_count_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_notification_events_count_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_notification_events_count_presult__isset { + _ThriftHiveMetastore_get_notification_events_count_presult__isset() : success(false) {} + bool success :1; +} _ThriftHiveMetastore_get_notification_events_count_presult__isset; + +class ThriftHiveMetastore_get_notification_events_count_presult { + public: + + + virtual ~ThriftHiveMetastore_get_notification_events_count_presult() throw(); + NotificationEventsCountResponse* success; + + _ThriftHiveMetastore_get_notification_events_count_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_fire_listener_event_args__isset { _ThriftHiveMetastore_fire_listener_event_args__isset() : rqst(false) {} bool rqst :1; @@ -20901,6 +21009,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public void get_current_notificationEventId(CurrentNotificationEventId& _return); void send_get_current_notificationEventId(); void recv_get_current_notificationEventId(CurrentNotificationEventId& _return); + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst); + void send_get_notification_events_count(const NotificationEventsCountRequest& rqst); + void recv_get_notification_events_count(NotificationEventsCountResponse& _return); void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst); void send_fire_listener_event(const FireEventRequest& rqst); void recv_fire_listener_event(FireEventResponse& _return); @@ -21089,6 +21200,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP 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); void process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_notification_events_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_fire_listener_event(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_cm_recycle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -21253,6 +21365,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["add_dynamic_partitions"] = &ThriftHiveMetastoreProcessor::process_add_dynamic_partitions; processMap_["get_next_notification"] = &ThriftHiveMetastoreProcessor::process_get_next_notification; processMap_["get_current_notificationEventId"] = &ThriftHiveMetastoreProcessor::process_get_current_notificationEventId; + processMap_["get_notification_events_count"] = &ThriftHiveMetastoreProcessor::process_get_notification_events_count; processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event; processMap_["flushCache"] = &ThriftHiveMetastoreProcessor::process_flushCache; processMap_["cm_recycle"] = &ThriftHiveMetastoreProcessor::process_cm_recycle; @@ -22740,6 +22853,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return; } + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_notification_events_count(_return, rqst); + } + ifaces_[i]->get_notification_events_count(_return, rqst); + return; + } + void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) { size_t sz = ifaces_.size(); size_t i = 0; @@ -23298,6 +23421,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf void get_current_notificationEventId(CurrentNotificationEventId& _return); int32_t send_get_current_notificationEventId(); void recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid); + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst); + int32_t send_get_notification_events_count(const NotificationEventsCountRequest& rqst); + void recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid); void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst); int32_t send_fire_listener_event(const FireEventRequest& rqst); void recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid);
http://git-wip-us.apache.org/repos/asf/hive/blob/70cb7f0b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index ec2071a..c656d5f 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -777,6 +777,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("get_current_notificationEventId\n"); } + void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) { + // Your implementation goes here + printf("get_notification_events_count\n"); + } + void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) { // Your implementation goes here printf("fire_listener_event\n"); http://git-wip-us.apache.org/repos/asf/hive/blob/70cb7f0b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index a4f72b6..5c09fdd 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -17218,6 +17218,201 @@ void CurrentNotificationEventId::printTo(std::ostream& out) const { } +NotificationEventsCountRequest::~NotificationEventsCountRequest() throw() { +} + + +void NotificationEventsCountRequest::__set_fromEventId(const int64_t val) { + this->fromEventId = val; +} + +void NotificationEventsCountRequest::__set_dbName(const std::string& val) { + this->dbName = val; +} + +uint32_t NotificationEventsCountRequest::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_fromEventId = false; + bool isset_dbName = 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->fromEventId); + isset_fromEventId = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + isset_dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_fromEventId) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_dbName) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventsCountRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventsCountRequest"); + + xfer += oprot->writeFieldBegin("fromEventId", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->fromEventId); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b) { + using ::std::swap; + swap(a.fromEventId, b.fromEventId); + swap(a.dbName, b.dbName); +} + +NotificationEventsCountRequest::NotificationEventsCountRequest(const NotificationEventsCountRequest& other690) { + fromEventId = other690.fromEventId; + dbName = other690.dbName; +} +NotificationEventsCountRequest& NotificationEventsCountRequest::operator=(const NotificationEventsCountRequest& other691) { + fromEventId = other691.fromEventId; + dbName = other691.dbName; + return *this; +} +void NotificationEventsCountRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventsCountRequest("; + out << "fromEventId=" << to_string(fromEventId); + out << ", " << "dbName=" << to_string(dbName); + out << ")"; +} + + +NotificationEventsCountResponse::~NotificationEventsCountResponse() throw() { +} + + +void NotificationEventsCountResponse::__set_eventsCount(const int64_t val) { + this->eventsCount = val; +} + +uint32_t NotificationEventsCountResponse::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_eventsCount = 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->eventsCount); + isset_eventsCount = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_eventsCount) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t NotificationEventsCountResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("NotificationEventsCountResponse"); + + xfer += oprot->writeFieldBegin("eventsCount", ::apache::thrift::protocol::T_I64, 1); + xfer += oprot->writeI64(this->eventsCount); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b) { + using ::std::swap; + swap(a.eventsCount, b.eventsCount); +} + +NotificationEventsCountResponse::NotificationEventsCountResponse(const NotificationEventsCountResponse& other692) { + eventsCount = other692.eventsCount; +} +NotificationEventsCountResponse& NotificationEventsCountResponse::operator=(const NotificationEventsCountResponse& other693) { + eventsCount = other693.eventsCount; + return *this; +} +void NotificationEventsCountResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "NotificationEventsCountResponse("; + out << "eventsCount=" << to_string(eventsCount); + out << ")"; +} + + InsertEventRequestData::~InsertEventRequestData() throw() { } @@ -17270,14 +17465,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size690; - ::apache::thrift::protocol::TType _etype693; - xfer += iprot->readListBegin(_etype693, _size690); - this->filesAdded.resize(_size690); - uint32_t _i694; - for (_i694 = 0; _i694 < _size690; ++_i694) + uint32_t _size694; + ::apache::thrift::protocol::TType _etype697; + xfer += iprot->readListBegin(_etype697, _size694); + this->filesAdded.resize(_size694); + uint32_t _i698; + for (_i698 = 0; _i698 < _size694; ++_i698) { - xfer += iprot->readString(this->filesAdded[_i694]); + xfer += iprot->readString(this->filesAdded[_i698]); } xfer += iprot->readListEnd(); } @@ -17290,14 +17485,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAddedChecksum.clear(); - uint32_t _size695; - ::apache::thrift::protocol::TType _etype698; - xfer += iprot->readListBegin(_etype698, _size695); - this->filesAddedChecksum.resize(_size695); - uint32_t _i699; - for (_i699 = 0; _i699 < _size695; ++_i699) + uint32_t _size699; + ::apache::thrift::protocol::TType _etype702; + xfer += iprot->readListBegin(_etype702, _size699); + this->filesAddedChecksum.resize(_size699); + uint32_t _i703; + for (_i703 = 0; _i703 < _size699; ++_i703) { - xfer += iprot->readString(this->filesAddedChecksum[_i699]); + xfer += iprot->readString(this->filesAddedChecksum[_i703]); } xfer += iprot->readListEnd(); } @@ -17333,10 +17528,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAdded.size())); - std::vector<std::string> ::const_iterator _iter700; - for (_iter700 = this->filesAdded.begin(); _iter700 != this->filesAdded.end(); ++_iter700) + std::vector<std::string> ::const_iterator _iter704; + for (_iter704 = this->filesAdded.begin(); _iter704 != this->filesAdded.end(); ++_iter704) { - xfer += oprot->writeString((*_iter700)); + xfer += oprot->writeString((*_iter704)); } xfer += oprot->writeListEnd(); } @@ -17346,10 +17541,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAddedChecksum", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->filesAddedChecksum.size())); - std::vector<std::string> ::const_iterator _iter701; - for (_iter701 = this->filesAddedChecksum.begin(); _iter701 != this->filesAddedChecksum.end(); ++_iter701) + std::vector<std::string> ::const_iterator _iter705; + for (_iter705 = this->filesAddedChecksum.begin(); _iter705 != this->filesAddedChecksum.end(); ++_iter705) { - xfer += oprot->writeString((*_iter701)); + xfer += oprot->writeString((*_iter705)); } xfer += oprot->writeListEnd(); } @@ -17368,17 +17563,17 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.__isset, b.__isset); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other702) { - replace = other702.replace; - filesAdded = other702.filesAdded; - filesAddedChecksum = other702.filesAddedChecksum; - __isset = other702.__isset; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other706) { + replace = other706.replace; + filesAdded = other706.filesAdded; + filesAddedChecksum = other706.filesAddedChecksum; + __isset = other706.__isset; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other703) { - replace = other703.replace; - filesAdded = other703.filesAdded; - filesAddedChecksum = other703.filesAddedChecksum; - __isset = other703.__isset; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other707) { + replace = other707.replace; + filesAdded = other707.filesAdded; + filesAddedChecksum = other707.filesAddedChecksum; + __isset = other707.__isset; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -17460,13 +17655,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other704) { - insertData = other704.insertData; - __isset = other704.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other708) { + insertData = other708.insertData; + __isset = other708.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other705) { - insertData = other705.insertData; - __isset = other705.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other709) { + insertData = other709.insertData; + __isset = other709.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -17563,14 +17758,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size706; - ::apache::thrift::protocol::TType _etype709; - xfer += iprot->readListBegin(_etype709, _size706); - this->partitionVals.resize(_size706); - uint32_t _i710; - for (_i710 = 0; _i710 < _size706; ++_i710) + uint32_t _size710; + ::apache::thrift::protocol::TType _etype713; + xfer += iprot->readListBegin(_etype713, _size710); + this->partitionVals.resize(_size710); + uint32_t _i714; + for (_i714 = 0; _i714 < _size710; ++_i714) { - xfer += iprot->readString(this->partitionVals[_i710]); + xfer += iprot->readString(this->partitionVals[_i714]); } xfer += iprot->readListEnd(); } @@ -17622,10 +17817,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 _iter711; - for (_iter711 = this->partitionVals.begin(); _iter711 != this->partitionVals.end(); ++_iter711) + std::vector<std::string> ::const_iterator _iter715; + for (_iter715 = this->partitionVals.begin(); _iter715 != this->partitionVals.end(); ++_iter715) { - xfer += oprot->writeString((*_iter711)); + xfer += oprot->writeString((*_iter715)); } xfer += oprot->writeListEnd(); } @@ -17646,21 +17841,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other712) { - successful = other712.successful; - data = other712.data; - dbName = other712.dbName; - tableName = other712.tableName; - partitionVals = other712.partitionVals; - __isset = other712.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other713) { - successful = other713.successful; - data = other713.data; - dbName = other713.dbName; - tableName = other713.tableName; - partitionVals = other713.partitionVals; - __isset = other713.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other716) { + successful = other716.successful; + data = other716.data; + dbName = other716.dbName; + tableName = other716.tableName; + partitionVals = other716.partitionVals; + __isset = other716.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other717) { + successful = other717.successful; + data = other717.data; + dbName = other717.dbName; + tableName = other717.tableName; + partitionVals = other717.partitionVals; + __isset = other717.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -17723,11 +17918,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other714) { - (void) other714; +FireEventResponse::FireEventResponse(const FireEventResponse& other718) { + (void) other718; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other715) { - (void) other715; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other719) { + (void) other719; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -17827,15 +18022,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other716) { - metadata = other716.metadata; - includeBitset = other716.includeBitset; - __isset = other716.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other720) { + metadata = other720.metadata; + includeBitset = other720.includeBitset; + __isset = other720.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other717) { - metadata = other717.metadata; - includeBitset = other717.includeBitset; - __isset = other717.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other721) { + metadata = other721.metadata; + includeBitset = other721.includeBitset; + __isset = other721.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -17886,17 +18081,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size718; - ::apache::thrift::protocol::TType _ktype719; - ::apache::thrift::protocol::TType _vtype720; - xfer += iprot->readMapBegin(_ktype719, _vtype720, _size718); - uint32_t _i722; - for (_i722 = 0; _i722 < _size718; ++_i722) + uint32_t _size722; + ::apache::thrift::protocol::TType _ktype723; + ::apache::thrift::protocol::TType _vtype724; + xfer += iprot->readMapBegin(_ktype723, _vtype724, _size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - int64_t _key723; - xfer += iprot->readI64(_key723); - MetadataPpdResult& _val724 = this->metadata[_key723]; - xfer += _val724.read(iprot); + int64_t _key727; + xfer += iprot->readI64(_key727); + MetadataPpdResult& _val728 = this->metadata[_key727]; + xfer += _val728.read(iprot); } xfer += iprot->readMapEnd(); } @@ -17937,11 +18132,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 _iter725; - for (_iter725 = this->metadata.begin(); _iter725 != this->metadata.end(); ++_iter725) + std::map<int64_t, MetadataPpdResult> ::const_iterator _iter729; + for (_iter729 = this->metadata.begin(); _iter729 != this->metadata.end(); ++_iter729) { - xfer += oprot->writeI64(_iter725->first); - xfer += _iter725->second.write(oprot); + xfer += oprot->writeI64(_iter729->first); + xfer += _iter729->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -17962,13 +18157,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other726) { - metadata = other726.metadata; - isSupported = other726.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other730) { + metadata = other730.metadata; + isSupported = other730.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other727) { - metadata = other727.metadata; - isSupported = other727.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other731) { + metadata = other731.metadata; + isSupported = other731.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -18029,14 +18224,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size728; - ::apache::thrift::protocol::TType _etype731; - xfer += iprot->readListBegin(_etype731, _size728); - this->fileIds.resize(_size728); - uint32_t _i732; - for (_i732 = 0; _i732 < _size728; ++_i732) + uint32_t _size732; + ::apache::thrift::protocol::TType _etype735; + xfer += iprot->readListBegin(_etype735, _size732); + this->fileIds.resize(_size732); + uint32_t _i736; + for (_i736 = 0; _i736 < _size732; ++_i736) { - xfer += iprot->readI64(this->fileIds[_i732]); + xfer += iprot->readI64(this->fileIds[_i736]); } xfer += iprot->readListEnd(); } @@ -18063,9 +18258,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast733; - xfer += iprot->readI32(ecast733); - this->type = (FileMetadataExprType::type)ecast733; + int32_t ecast737; + xfer += iprot->readI32(ecast737); + this->type = (FileMetadataExprType::type)ecast737; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -18095,10 +18290,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 _iter734; - for (_iter734 = this->fileIds.begin(); _iter734 != this->fileIds.end(); ++_iter734) + std::vector<int64_t> ::const_iterator _iter738; + for (_iter738 = this->fileIds.begin(); _iter738 != this->fileIds.end(); ++_iter738) { - xfer += oprot->writeI64((*_iter734)); + xfer += oprot->writeI64((*_iter738)); } xfer += oprot->writeListEnd(); } @@ -18132,19 +18327,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other735) { - fileIds = other735.fileIds; - expr = other735.expr; - doGetFooters = other735.doGetFooters; - type = other735.type; - __isset = other735.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other739) { + fileIds = other739.fileIds; + expr = other739.expr; + doGetFooters = other739.doGetFooters; + type = other739.type; + __isset = other739.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other736) { - fileIds = other736.fileIds; - expr = other736.expr; - doGetFooters = other736.doGetFooters; - type = other736.type; - __isset = other736.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other740) { + fileIds = other740.fileIds; + expr = other740.expr; + doGetFooters = other740.doGetFooters; + type = other740.type; + __isset = other740.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -18197,17 +18392,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size737; - ::apache::thrift::protocol::TType _ktype738; - ::apache::thrift::protocol::TType _vtype739; - xfer += iprot->readMapBegin(_ktype738, _vtype739, _size737); - uint32_t _i741; - for (_i741 = 0; _i741 < _size737; ++_i741) + uint32_t _size741; + ::apache::thrift::protocol::TType _ktype742; + ::apache::thrift::protocol::TType _vtype743; + xfer += iprot->readMapBegin(_ktype742, _vtype743, _size741); + uint32_t _i745; + for (_i745 = 0; _i745 < _size741; ++_i745) { - int64_t _key742; - xfer += iprot->readI64(_key742); - std::string& _val743 = this->metadata[_key742]; - xfer += iprot->readBinary(_val743); + int64_t _key746; + xfer += iprot->readI64(_key746); + std::string& _val747 = this->metadata[_key746]; + xfer += iprot->readBinary(_val747); } xfer += iprot->readMapEnd(); } @@ -18248,11 +18443,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 _iter744; - for (_iter744 = this->metadata.begin(); _iter744 != this->metadata.end(); ++_iter744) + std::map<int64_t, std::string> ::const_iterator _iter748; + for (_iter748 = this->metadata.begin(); _iter748 != this->metadata.end(); ++_iter748) { - xfer += oprot->writeI64(_iter744->first); - xfer += oprot->writeBinary(_iter744->second); + xfer += oprot->writeI64(_iter748->first); + xfer += oprot->writeBinary(_iter748->second); } xfer += oprot->writeMapEnd(); } @@ -18273,13 +18468,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other745) { - metadata = other745.metadata; - isSupported = other745.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other749) { + metadata = other749.metadata; + isSupported = other749.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other746) { - metadata = other746.metadata; - isSupported = other746.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other750) { + metadata = other750.metadata; + isSupported = other750.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -18325,14 +18520,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - this->fileIds.resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size751; + ::apache::thrift::protocol::TType _etype754; + xfer += iprot->readListBegin(_etype754, _size751); + this->fileIds.resize(_size751); + uint32_t _i755; + for (_i755 = 0; _i755 < _size751; ++_i755) { - xfer += iprot->readI64(this->fileIds[_i751]); + xfer += iprot->readI64(this->fileIds[_i755]); } xfer += iprot->readListEnd(); } @@ -18363,10 +18558,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 _iter752; - for (_iter752 = this->fileIds.begin(); _iter752 != this->fileIds.end(); ++_iter752) + std::vector<int64_t> ::const_iterator _iter756; + for (_iter756 = this->fileIds.begin(); _iter756 != this->fileIds.end(); ++_iter756) { - xfer += oprot->writeI64((*_iter752)); + xfer += oprot->writeI64((*_iter756)); } xfer += oprot->writeListEnd(); } @@ -18382,11 +18577,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other753) { - fileIds = other753.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other757) { + fileIds = other757.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other754) { - fileIds = other754.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other758) { + fileIds = other758.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -18445,11 +18640,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other755) { - (void) other755; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other759) { + (void) other759; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other756) { - (void) other756; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other760) { + (void) other760; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -18503,14 +18698,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size757; - ::apache::thrift::protocol::TType _etype760; - xfer += iprot->readListBegin(_etype760, _size757); - this->fileIds.resize(_size757); - uint32_t _i761; - for (_i761 = 0; _i761 < _size757; ++_i761) + uint32_t _size761; + ::apache::thrift::protocol::TType _etype764; + xfer += iprot->readListBegin(_etype764, _size761); + this->fileIds.resize(_size761); + uint32_t _i765; + for (_i765 = 0; _i765 < _size761; ++_i765) { - xfer += iprot->readI64(this->fileIds[_i761]); + xfer += iprot->readI64(this->fileIds[_i765]); } xfer += iprot->readListEnd(); } @@ -18523,14 +18718,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size762; - ::apache::thrift::protocol::TType _etype765; - xfer += iprot->readListBegin(_etype765, _size762); - this->metadata.resize(_size762); - uint32_t _i766; - for (_i766 = 0; _i766 < _size762; ++_i766) + uint32_t _size766; + ::apache::thrift::protocol::TType _etype769; + xfer += iprot->readListBegin(_etype769, _size766); + this->metadata.resize(_size766); + uint32_t _i770; + for (_i770 = 0; _i770 < _size766; ++_i770) { - xfer += iprot->readBinary(this->metadata[_i766]); + xfer += iprot->readBinary(this->metadata[_i770]); } xfer += iprot->readListEnd(); } @@ -18541,9 +18736,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast767; - xfer += iprot->readI32(ecast767); - this->type = (FileMetadataExprType::type)ecast767; + int32_t ecast771; + xfer += iprot->readI32(ecast771); + this->type = (FileMetadataExprType::type)ecast771; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -18573,10 +18768,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 _iter768; - for (_iter768 = this->fileIds.begin(); _iter768 != this->fileIds.end(); ++_iter768) + std::vector<int64_t> ::const_iterator _iter772; + for (_iter772 = this->fileIds.begin(); _iter772 != this->fileIds.end(); ++_iter772) { - xfer += oprot->writeI64((*_iter768)); + xfer += oprot->writeI64((*_iter772)); } xfer += oprot->writeListEnd(); } @@ -18585,10 +18780,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 _iter769; - for (_iter769 = this->metadata.begin(); _iter769 != this->metadata.end(); ++_iter769) + std::vector<std::string> ::const_iterator _iter773; + for (_iter773 = this->metadata.begin(); _iter773 != this->metadata.end(); ++_iter773) { - xfer += oprot->writeBinary((*_iter769)); + xfer += oprot->writeBinary((*_iter773)); } xfer += oprot->writeListEnd(); } @@ -18612,17 +18807,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other770) { - fileIds = other770.fileIds; - metadata = other770.metadata; - type = other770.type; - __isset = other770.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other774) { + fileIds = other774.fileIds; + metadata = other774.metadata; + type = other774.type; + __isset = other774.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other771) { - fileIds = other771.fileIds; - metadata = other771.metadata; - type = other771.type; - __isset = other771.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other775) { + fileIds = other775.fileIds; + metadata = other775.metadata; + type = other775.type; + __isset = other775.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -18683,11 +18878,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other772) { - (void) other772; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other776) { + (void) other776; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other773) { - (void) other773; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other777) { + (void) other777; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -18731,14 +18926,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size774; - ::apache::thrift::protocol::TType _etype777; - xfer += iprot->readListBegin(_etype777, _size774); - this->fileIds.resize(_size774); - uint32_t _i778; - for (_i778 = 0; _i778 < _size774; ++_i778) + uint32_t _size778; + ::apache::thrift::protocol::TType _etype781; + xfer += iprot->readListBegin(_etype781, _size778); + this->fileIds.resize(_size778); + uint32_t _i782; + for (_i782 = 0; _i782 < _size778; ++_i782) { - xfer += iprot->readI64(this->fileIds[_i778]); + xfer += iprot->readI64(this->fileIds[_i782]); } xfer += iprot->readListEnd(); } @@ -18769,10 +18964,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 _iter779; - for (_iter779 = this->fileIds.begin(); _iter779 != this->fileIds.end(); ++_iter779) + std::vector<int64_t> ::const_iterator _iter783; + for (_iter783 = this->fileIds.begin(); _iter783 != this->fileIds.end(); ++_iter783) { - xfer += oprot->writeI64((*_iter779)); + xfer += oprot->writeI64((*_iter783)); } xfer += oprot->writeListEnd(); } @@ -18788,11 +18983,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other780) { - fileIds = other780.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other784) { + fileIds = other784.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other781) { - fileIds = other781.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other785) { + fileIds = other785.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -18874,11 +19069,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other782) { - isSupported = other782.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other786) { + isSupported = other786.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other783) { - isSupported = other783.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other787) { + isSupported = other787.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -19019,19 +19214,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other784) { - dbName = other784.dbName; - tblName = other784.tblName; - partName = other784.partName; - isAllParts = other784.isAllParts; - __isset = other784.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other788) { + dbName = other788.dbName; + tblName = other788.tblName; + partName = other788.partName; + isAllParts = other788.isAllParts; + __isset = other788.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other785) { - dbName = other785.dbName; - tblName = other785.tblName; - partName = other785.partName; - isAllParts = other785.isAllParts; - __isset = other785.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other789) { + dbName = other789.dbName; + tblName = other789.tblName; + partName = other789.partName; + isAllParts = other789.isAllParts; + __isset = other789.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -19079,14 +19274,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size786; - ::apache::thrift::protocol::TType _etype789; - xfer += iprot->readListBegin(_etype789, _size786); - this->functions.resize(_size786); - uint32_t _i790; - for (_i790 = 0; _i790 < _size786; ++_i790) + uint32_t _size790; + ::apache::thrift::protocol::TType _etype793; + xfer += iprot->readListBegin(_etype793, _size790); + this->functions.resize(_size790); + uint32_t _i794; + for (_i794 = 0; _i794 < _size790; ++_i794) { - xfer += this->functions[_i790].read(iprot); + xfer += this->functions[_i794].read(iprot); } xfer += iprot->readListEnd(); } @@ -19116,10 +19311,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 _iter791; - for (_iter791 = this->functions.begin(); _iter791 != this->functions.end(); ++_iter791) + std::vector<Function> ::const_iterator _iter795; + for (_iter795 = this->functions.begin(); _iter795 != this->functions.end(); ++_iter795) { - xfer += (*_iter791).write(oprot); + xfer += (*_iter795).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19136,13 +19331,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other792) { - functions = other792.functions; - __isset = other792.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other796) { + functions = other796.functions; + __isset = other796.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other793) { - functions = other793.functions; - __isset = other793.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other797) { + functions = other797.functions; + __isset = other797.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -19187,16 +19382,16 @@ uint32_t ClientCapabilities::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size794; - ::apache::thrift::protocol::TType _etype797; - xfer += iprot->readListBegin(_etype797, _size794); - this->values.resize(_size794); - uint32_t _i798; - for (_i798 = 0; _i798 < _size794; ++_i798) + uint32_t _size798; + ::apache::thrift::protocol::TType _etype801; + xfer += iprot->readListBegin(_etype801, _size798); + this->values.resize(_size798); + uint32_t _i802; + for (_i802 = 0; _i802 < _size798; ++_i802) { - int32_t ecast799; - xfer += iprot->readI32(ecast799); - this->values[_i798] = (ClientCapability::type)ecast799; + int32_t ecast803; + xfer += iprot->readI32(ecast803); + this->values[_i802] = (ClientCapability::type)ecast803; } xfer += iprot->readListEnd(); } @@ -19227,10 +19422,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 _iter800; - for (_iter800 = this->values.begin(); _iter800 != this->values.end(); ++_iter800) + std::vector<ClientCapability::type> ::const_iterator _iter804; + for (_iter804 = this->values.begin(); _iter804 != this->values.end(); ++_iter804) { - xfer += oprot->writeI32((int32_t)(*_iter800)); + xfer += oprot->writeI32((int32_t)(*_iter804)); } xfer += oprot->writeListEnd(); } @@ -19246,11 +19441,11 @@ void swap(ClientCapabilities &a, ClientCapabilities &b) { swap(a.values, b.values); } -ClientCapabilities::ClientCapabilities(const ClientCapabilities& other801) { - values = other801.values; +ClientCapabilities::ClientCapabilities(const ClientCapabilities& other805) { + values = other805.values; } -ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other802) { - values = other802.values; +ClientCapabilities& ClientCapabilities::operator=(const ClientCapabilities& other806) { + values = other806.values; return *this; } void ClientCapabilities::printTo(std::ostream& out) const { @@ -19372,17 +19567,17 @@ void swap(GetTableRequest &a, GetTableRequest &b) { swap(a.__isset, b.__isset); } -GetTableRequest::GetTableRequest(const GetTableRequest& other803) { - dbName = other803.dbName; - tblName = other803.tblName; - capabilities = other803.capabilities; - __isset = other803.__isset; +GetTableRequest::GetTableRequest(const GetTableRequest& other807) { + dbName = other807.dbName; + tblName = other807.tblName; + capabilities = other807.capabilities; + __isset = other807.__isset; } -GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other804) { - dbName = other804.dbName; - tblName = other804.tblName; - capabilities = other804.capabilities; - __isset = other804.__isset; +GetTableRequest& GetTableRequest::operator=(const GetTableRequest& other808) { + dbName = other808.dbName; + tblName = other808.tblName; + capabilities = other808.capabilities; + __isset = other808.__isset; return *this; } void GetTableRequest::printTo(std::ostream& out) const { @@ -19466,11 +19661,11 @@ void swap(GetTableResult &a, GetTableResult &b) { swap(a.table, b.table); } -GetTableResult::GetTableResult(const GetTableResult& other805) { - table = other805.table; +GetTableResult::GetTableResult(const GetTableResult& other809) { + table = other809.table; } -GetTableResult& GetTableResult::operator=(const GetTableResult& other806) { - table = other806.table; +GetTableResult& GetTableResult::operator=(const GetTableResult& other810) { + table = other810.table; return *this; } void GetTableResult::printTo(std::ostream& out) const { @@ -19533,14 +19728,14 @@ uint32_t GetTablesRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tblNames.clear(); - uint32_t _size807; - ::apache::thrift::protocol::TType _etype810; - xfer += iprot->readListBegin(_etype810, _size807); - this->tblNames.resize(_size807); - uint32_t _i811; - for (_i811 = 0; _i811 < _size807; ++_i811) + uint32_t _size811; + ::apache::thrift::protocol::TType _etype814; + xfer += iprot->readListBegin(_etype814, _size811); + this->tblNames.resize(_size811); + uint32_t _i815; + for (_i815 = 0; _i815 < _size811; ++_i815) { - xfer += iprot->readString(this->tblNames[_i811]); + xfer += iprot->readString(this->tblNames[_i815]); } xfer += iprot->readListEnd(); } @@ -19584,10 +19779,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 _iter812; - for (_iter812 = this->tblNames.begin(); _iter812 != this->tblNames.end(); ++_iter812) + std::vector<std::string> ::const_iterator _iter816; + for (_iter816 = this->tblNames.begin(); _iter816 != this->tblNames.end(); ++_iter816) { - xfer += oprot->writeString((*_iter812)); + xfer += oprot->writeString((*_iter816)); } xfer += oprot->writeListEnd(); } @@ -19611,17 +19806,17 @@ void swap(GetTablesRequest &a, GetTablesRequest &b) { swap(a.__isset, b.__isset); } -GetTablesRequest::GetTablesRequest(const GetTablesRequest& other813) { - dbName = other813.dbName; - tblNames = other813.tblNames; - capabilities = other813.capabilities; - __isset = other813.__isset; +GetTablesRequest::GetTablesRequest(const GetTablesRequest& other817) { + dbName = other817.dbName; + tblNames = other817.tblNames; + capabilities = other817.capabilities; + __isset = other817.__isset; } -GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other814) { - dbName = other814.dbName; - tblNames = other814.tblNames; - capabilities = other814.capabilities; - __isset = other814.__isset; +GetTablesRequest& GetTablesRequest::operator=(const GetTablesRequest& other818) { + dbName = other818.dbName; + tblNames = other818.tblNames; + capabilities = other818.capabilities; + __isset = other818.__isset; return *this; } void GetTablesRequest::printTo(std::ostream& out) const { @@ -19668,14 +19863,14 @@ uint32_t GetTablesResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size815; - ::apache::thrift::protocol::TType _etype818; - xfer += iprot->readListBegin(_etype818, _size815); - this->tables.resize(_size815); - uint32_t _i819; - for (_i819 = 0; _i819 < _size815; ++_i819) + uint32_t _size819; + ::apache::thrift::protocol::TType _etype822; + xfer += iprot->readListBegin(_etype822, _size819); + this->tables.resize(_size819); + uint32_t _i823; + for (_i823 = 0; _i823 < _size819; ++_i823) { - xfer += this->tables[_i819].read(iprot); + xfer += this->tables[_i823].read(iprot); } xfer += iprot->readListEnd(); } @@ -19706,10 +19901,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 _iter820; - for (_iter820 = this->tables.begin(); _iter820 != this->tables.end(); ++_iter820) + std::vector<Table> ::const_iterator _iter824; + for (_iter824 = this->tables.begin(); _iter824 != this->tables.end(); ++_iter824) { - xfer += (*_iter820).write(oprot); + xfer += (*_iter824).write(oprot); } xfer += oprot->writeListEnd(); } @@ -19725,11 +19920,11 @@ void swap(GetTablesResult &a, GetTablesResult &b) { swap(a.tables, b.tables); } -GetTablesResult::GetTablesResult(const GetTablesResult& other821) { - tables = other821.tables; +GetTablesResult::GetTablesResult(const GetTablesResult& other825) { + tables = other825.tables; } -GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other822) { - tables = other822.tables; +GetTablesResult& GetTablesResult::operator=(const GetTablesResult& other826) { + tables = other826.tables; return *this; } void GetTablesResult::printTo(std::ostream& out) const { @@ -19831,13 +20026,13 @@ void swap(CmRecycleRequest &a, CmRecycleRequest &b) { swap(a.purge, b.purge); } -CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other823) { - dataPath = other823.dataPath; - purge = other823.purge; +CmRecycleRequest::CmRecycleRequest(const CmRecycleRequest& other827) { + dataPath = other827.dataPath; + purge = other827.purge; } -CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other824) { - dataPath = other824.dataPath; - purge = other824.purge; +CmRecycleRequest& CmRecycleRequest::operator=(const CmRecycleRequest& other828) { + dataPath = other828.dataPath; + purge = other828.purge; return *this; } void CmRecycleRequest::printTo(std::ostream& out) const { @@ -19897,11 +20092,11 @@ void swap(CmRecycleResponse &a, CmRecycleResponse &b) { (void) b; } -CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other825) { - (void) other825; +CmRecycleResponse::CmRecycleResponse(const CmRecycleResponse& other829) { + (void) other829; } -CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other826) { - (void) other826; +CmRecycleResponse& CmRecycleResponse::operator=(const CmRecycleResponse& other830) { + (void) other830; return *this; } void CmRecycleResponse::printTo(std::ostream& out) const { @@ -20042,19 +20237,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other827) { - dbName = other827.dbName; - tableName = other827.tableName; - tableType = other827.tableType; - comments = other827.comments; - __isset = other827.__isset; +TableMeta::TableMeta(const TableMeta& other831) { + dbName = other831.dbName; + tableName = other831.tableName; + tableType = other831.tableType; + comments = other831.comments; + __isset = other831.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other828) { - dbName = other828.dbName; - tableName = other828.tableName; - tableType = other828.tableType; - comments = other828.comments; - __isset = other828.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other832) { + dbName = other832.dbName; + tableName = other832.tableName; + tableType = other832.tableType; + comments = other832.comments; + __isset = other832.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -20137,13 +20332,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other829) : TException() { - message = other829.message; - __isset = other829.__isset; +MetaException::MetaException(const MetaException& other833) : TException() { + message = other833.message; + __isset = other833.__isset; } -MetaException& MetaException::operator=(const MetaException& other830) { - message = other830.message; - __isset = other830.__isset; +MetaException& MetaException::operator=(const MetaException& other834) { + message = other834.message; + __isset = other834.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -20234,13 +20429,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other831) : TException() { - message = other831.message; - __isset = other831.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other835) : TException() { + message = other835.message; + __isset = other835.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other832) { - message = other832.message; - __isset = other832.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other836) { + message = other836.message; + __isset = other836.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -20331,13 +20526,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other833) : TException() { - message = other833.message; - __isset = other833.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other837) : TException() { + message = other837.message; + __isset = other837.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other834) { - message = other834.message; - __isset = other834.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other838) { + message = other838.message; + __isset = other838.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -20428,13 +20623,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other835) : TException() { - message = other835.message; - __isset = other835.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other839) : TException() { + message = other839.message; + __isset = other839.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other836) { - message = other836.message; - __isset = other836.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other840) { + message = other840.message; + __isset = other840.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -20525,13 +20720,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other837) : TException() { - message = other837.message; - __isset = other837.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other841) : TException() { + message = other841.message; + __isset = other841.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other838) { - message = other838.message; - __isset = other838.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other842) { + message = other842.message; + __isset = other842.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -20622,13 +20817,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other839) : TException() { - message = other839.message; - __isset = other839.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other843) : TException() { + message = other843.message; + __isset = other843.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other840) { - message = other840.message; - __isset = other840.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other844) { + message = other844.message; + __isset = other844.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -20719,13 +20914,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other841) : TException() { - message = other841.message; - __isset = other841.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other845) : TException() { + message = other845.message; + __isset = other845.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other842) { - message = other842.message; - __isset = other842.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other846) { + message = other846.message; + __isset = other846.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -20816,13 +21011,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other843) : TException() { - message = other843.message; - __isset = other843.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other847) : TException() { + message = other847.message; + __isset = other847.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other844) { - message = other844.message; - __isset = other844.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other848) { + message = other848.message; + __isset = other848.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -20913,13 +21108,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other845) : TException() { - message = other845.message; - __isset = other845.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other849) : TException() { + message = other849.message; + __isset = other849.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other846) { - message = other846.message; - __isset = other846.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other850) { + message = other850.message; + __isset = other850.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -21010,13 +21205,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other847) : TException() { - message = other847.message; - __isset = other847.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other851) : TException() { + message = other851.message; + __isset = other851.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other848) { - message = other848.message; - __isset = other848.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other852) { + message = other852.message; + __isset = other852.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -21107,13 +21302,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other849) : TException() { - message = other849.message; - __isset = other849.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other853) : TException() { + message = other853.message; + __isset = other853.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other850) { - message = other850.message; - __isset = other850.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other854) { + message = other854.message; + __isset = other854.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -21204,13 +21399,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other851) : TException() { - message = other851.message; - __isset = other851.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other855) : TException() { + message = other855.message; + __isset = other855.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other852) { - message = other852.message; - __isset = other852.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other856) { + message = other856.message; + __isset = other856.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -21301,13 +21496,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other853) : TException() { - message = other853.message; - __isset = other853.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other857) : TException() { + message = other857.message; + __isset = other857.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other854) { - message = other854.message; - __isset = other854.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other858) { + message = other858.message; + __isset = other858.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -21398,13 +21593,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other855) : TException() { - message = other855.message; - __isset = other855.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other859) : TException() { + message = other859.message; + __isset = other859.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other856) { - message = other856.message; - __isset = other856.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other860) { + message = other860.message; + __isset = other860.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -21495,13 +21690,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other857) : TException() { - message = other857.message; - __isset = other857.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other861) : TException() { + message = other861.message; + __isset = other861.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other858) { - message = other858.message; - __isset = other858.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other862) { + message = other862.message; + __isset = other862.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -21592,13 +21787,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other859) : TException() { - message = other859.message; - __isset = other859.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other863) : TException() { + message = other863.message; + __isset = other863.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other860) { - message = other860.message; - __isset = other860.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other864) { + message = other864.message; + __isset = other864.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { http://git-wip-us.apache.org/repos/asf/hive/blob/70cb7f0b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index 2bba534..d5963f3 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -380,6 +380,10 @@ class NotificationEventResponse; class CurrentNotificationEventId; +class NotificationEventsCountRequest; + +class NotificationEventsCountResponse; + class InsertEventRequestData; class FireEventRequestData; @@ -6999,6 +7003,91 @@ inline std::ostream& operator<<(std::ostream& out, const CurrentNotificationEven return out; } + +class NotificationEventsCountRequest { + public: + + NotificationEventsCountRequest(const NotificationEventsCountRequest&); + NotificationEventsCountRequest& operator=(const NotificationEventsCountRequest&); + NotificationEventsCountRequest() : fromEventId(0), dbName() { + } + + virtual ~NotificationEventsCountRequest() throw(); + int64_t fromEventId; + std::string dbName; + + void __set_fromEventId(const int64_t val); + + void __set_dbName(const std::string& val); + + bool operator == (const NotificationEventsCountRequest & rhs) const + { + if (!(fromEventId == rhs.fromEventId)) + return false; + if (!(dbName == rhs.dbName)) + return false; + return true; + } + bool operator != (const NotificationEventsCountRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventsCountRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventsCountRequest &a, NotificationEventsCountRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const NotificationEventsCountRequest& obj) +{ + obj.printTo(out); + return out; +} + + +class NotificationEventsCountResponse { + public: + + NotificationEventsCountResponse(const NotificationEventsCountResponse&); + NotificationEventsCountResponse& operator=(const NotificationEventsCountResponse&); + NotificationEventsCountResponse() : eventsCount(0) { + } + + virtual ~NotificationEventsCountResponse() throw(); + int64_t eventsCount; + + void __set_eventsCount(const int64_t val); + + bool operator == (const NotificationEventsCountResponse & rhs) const + { + if (!(eventsCount == rhs.eventsCount)) + return false; + return true; + } + bool operator != (const NotificationEventsCountResponse &rhs) const { + return !(*this == rhs); + } + + bool operator < (const NotificationEventsCountResponse & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(NotificationEventsCountResponse &a, NotificationEventsCountResponse &b); + +inline std::ostream& operator<<(std::ostream& out, const NotificationEventsCountResponse& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _InsertEventRequestData__isset { _InsertEventRequestData__isset() : replace(false), filesAddedChecksum(false) {} bool replace :1;
