Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original) +++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Tue Aug 5 05:52:51 2014 @@ -87,6 +87,7 @@ class ThriftHiveMetastoreIf : virtual pu virtual void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) = 0; virtual void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) = 0; virtual void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) = 0; + virtual void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) = 0; virtual bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) = 0; virtual bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0; virtual void create_function(const Function& func) = 0; @@ -379,6 +380,9 @@ class ThriftHiveMetastoreNull : virtual void get_partitions_statistics_req(PartitionsStatsResult& /* _return */, const PartitionsStatsRequest& /* request */) { return; } + void get_aggr_stats_for(AggrStats& /* _return */, const PartitionsStatsRequest& /* request */) { + return; + } bool delete_partition_column_statistics(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const std::string& /* col_name */) { bool _return = false; return _return; @@ -10760,6 +10764,134 @@ class ThriftHiveMetastore_get_partitions }; +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_args__isset { + _ThriftHiveMetastore_get_aggr_stats_for_args__isset() : request(false) {} + bool request; +} _ThriftHiveMetastore_get_aggr_stats_for_args__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_args { + public: + + ThriftHiveMetastore_get_aggr_stats_for_args() { + } + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_args() throw() {} + + PartitionsStatsRequest request; + + _ThriftHiveMetastore_get_aggr_stats_for_args__isset __isset; + + void __set_request(const PartitionsStatsRequest& val) { + request = val; + } + + bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_aggr_stats_for_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_get_aggr_stats_for_pargs { + public: + + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_pargs() throw() {} + + const PartitionsStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_result__isset { + _ThriftHiveMetastore_get_aggr_stats_for_result__isset() : success(false), o1(false), o2(false) {} + bool success; + bool o1; + bool o2; +} _ThriftHiveMetastore_get_aggr_stats_for_result__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_result { + public: + + ThriftHiveMetastore_get_aggr_stats_for_result() { + } + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_result() throw() {} + + AggrStats success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_aggr_stats_for_result__isset __isset; + + void __set_success(const AggrStats& val) { + success = val; + } + + void __set_o1(const NoSuchObjectException& val) { + o1 = val; + } + + void __set_o2(const MetaException& val) { + o2 = val; + } + + bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_get_aggr_stats_for_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_get_aggr_stats_for_presult__isset { + _ThriftHiveMetastore_get_aggr_stats_for_presult__isset() : success(false), o1(false), o2(false) {} + bool success; + bool o1; + bool o2; +} _ThriftHiveMetastore_get_aggr_stats_for_presult__isset; + +class ThriftHiveMetastore_get_aggr_stats_for_presult { + public: + + + virtual ~ThriftHiveMetastore_get_aggr_stats_for_presult() throw() {} + + AggrStats* success; + NoSuchObjectException o1; + MetaException o2; + + _ThriftHiveMetastore_get_aggr_stats_for_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_args__isset { _ThriftHiveMetastore_delete_partition_column_statistics_args__isset() : db_name(false), tbl_name(false), part_name(false), col_name(false) {} bool db_name; @@ -15663,6 +15795,9 @@ class ThriftHiveMetastoreClient : virtua void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request); void send_get_partitions_statistics_req(const PartitionsStatsRequest& request); void recv_get_partitions_statistics_req(PartitionsStatsResult& _return); + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request); + void send_get_aggr_stats_for(const PartitionsStatsRequest& request); + void recv_get_aggr_stats_for(AggrStats& _return); bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name); void send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name); bool recv_delete_partition_column_statistics(); @@ -15858,6 +15993,7 @@ class ThriftHiveMetastoreProcessor : pub void process_get_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_table_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partitions_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_get_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_delete_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_delete_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_create_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -15971,6 +16107,7 @@ class ThriftHiveMetastoreProcessor : pub processMap_["get_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_partition_column_statistics; processMap_["get_table_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_table_statistics_req; processMap_["get_partitions_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_statistics_req; + processMap_["get_aggr_stats_for"] = &ThriftHiveMetastoreProcessor::process_get_aggr_stats_for; processMap_["delete_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics; processMap_["delete_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_table_column_statistics; processMap_["create_function"] = &ThriftHiveMetastoreProcessor::process_create_function; @@ -16725,6 +16862,16 @@ class ThriftHiveMetastoreMultiface : vir return; } + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->get_aggr_stats_for(_return, request); + } + ifaces_[i]->get_aggr_stats_for(_return, request); + return; + } + bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) { size_t sz = ifaces_.size(); size_t i = 0;
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original) +++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Tue Aug 5 05:52:51 2014 @@ -377,6 +377,11 @@ class ThriftHiveMetastoreHandler : virtu printf("get_partitions_statistics_req\n"); } + void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) { + // Your implementation goes here + printf("get_aggr_stats_for\n"); + } + bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) { // Your implementation goes here printf("delete_partition_column_statistics\n"); Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original) +++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Tue Aug 5 05:52:51 2014 @@ -4668,10 +4668,10 @@ void swap(ColumnStatistics &a, ColumnSta swap(a.statsObj, b.statsObj); } -const char* Schema::ascii_fingerprint = "5CFEE46C975F4E2368D905109B8E3B5B"; -const uint8_t Schema::binary_fingerprint[16] = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B}; +const char* AggrStats::ascii_fingerprint = "399BDBAF7503E0BFB5E1D99C83D790CD"; +const uint8_t AggrStats::binary_fingerprint[16] = {0x39,0x9B,0xDB,0xAF,0x75,0x03,0xE0,0xBF,0xB5,0xE1,0xD9,0x9C,0x83,0xD7,0x90,0xCD}; -uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t xfer = 0; std::string fname; @@ -4682,6 +4682,8 @@ uint32_t Schema::read(::apache::thrift:: using ::apache::thrift::protocol::TProtocolException; + bool isset_colStats = false; + bool isset_partsFound = false; while (true) { @@ -4694,15 +4696,113 @@ uint32_t Schema::read(::apache::thrift:: case 1: if (ftype == ::apache::thrift::protocol::T_LIST) { { - this->fieldSchemas.clear(); + this->colStats.clear(); uint32_t _size199; ::apache::thrift::protocol::TType _etype202; xfer += iprot->readListBegin(_etype202, _size199); - this->fieldSchemas.resize(_size199); + this->colStats.resize(_size199); uint32_t _i203; for (_i203 = 0; _i203 < _size199; ++_i203) { - xfer += this->fieldSchemas[_i203].read(iprot); + xfer += this->colStats[_i203].read(iprot); + } + xfer += iprot->readListEnd(); + } + isset_colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I64) { + xfer += iprot->readI64(this->partsFound); + isset_partsFound = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_colStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + if (!isset_partsFound) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + xfer += oprot->writeStructBegin("AggrStats"); + + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colStats.size())); + std::vector<ColumnStatisticsObj> ::const_iterator _iter204; + for (_iter204 = this->colStats.begin(); _iter204 != this->colStats.end(); ++_iter204) + { + xfer += (*_iter204).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partsFound", ::apache::thrift::protocol::T_I64, 2); + xfer += oprot->writeI64(this->partsFound); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(AggrStats &a, AggrStats &b) { + using ::std::swap; + swap(a.colStats, b.colStats); + swap(a.partsFound, b.partsFound); +} + +const char* Schema::ascii_fingerprint = "5CFEE46C975F4E2368D905109B8E3B5B"; +const uint8_t Schema::binary_fingerprint[16] = {0x5C,0xFE,0xE4,0x6C,0x97,0x5F,0x4E,0x23,0x68,0xD9,0x05,0x10,0x9B,0x8E,0x3B,0x5B}; + +uint32_t Schema::read(::apache::thrift::protocol::TProtocol* 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; + + + 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_LIST) { + { + this->fieldSchemas.clear(); + uint32_t _size205; + ::apache::thrift::protocol::TType _etype208; + xfer += iprot->readListBegin(_etype208, _size205); + this->fieldSchemas.resize(_size205); + uint32_t _i209; + for (_i209 = 0; _i209 < _size205; ++_i209) + { + xfer += this->fieldSchemas[_i209].read(iprot); } xfer += iprot->readListEnd(); } @@ -4715,17 +4815,17 @@ uint32_t Schema::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size204; - ::apache::thrift::protocol::TType _ktype205; - ::apache::thrift::protocol::TType _vtype206; - xfer += iprot->readMapBegin(_ktype205, _vtype206, _size204); - uint32_t _i208; - for (_i208 = 0; _i208 < _size204; ++_i208) + uint32_t _size210; + ::apache::thrift::protocol::TType _ktype211; + ::apache::thrift::protocol::TType _vtype212; + xfer += iprot->readMapBegin(_ktype211, _vtype212, _size210); + uint32_t _i214; + for (_i214 = 0; _i214 < _size210; ++_i214) { - std::string _key209; - xfer += iprot->readString(_key209); - std::string& _val210 = this->properties[_key209]; - xfer += iprot->readString(_val210); + std::string _key215; + xfer += iprot->readString(_key215); + std::string& _val216 = this->properties[_key215]; + xfer += iprot->readString(_val216); } xfer += iprot->readMapEnd(); } @@ -4753,10 +4853,10 @@ uint32_t Schema::write(::apache::thrift: xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fieldSchemas.size())); - std::vector<FieldSchema> ::const_iterator _iter211; - for (_iter211 = this->fieldSchemas.begin(); _iter211 != this->fieldSchemas.end(); ++_iter211) + std::vector<FieldSchema> ::const_iterator _iter217; + for (_iter217 = this->fieldSchemas.begin(); _iter217 != this->fieldSchemas.end(); ++_iter217) { - xfer += (*_iter211).write(oprot); + xfer += (*_iter217).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4765,11 +4865,11 @@ uint32_t Schema::write(::apache::thrift: xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size())); - std::map<std::string, std::string> ::const_iterator _iter212; - for (_iter212 = this->properties.begin(); _iter212 != this->properties.end(); ++_iter212) + std::map<std::string, std::string> ::const_iterator _iter218; + for (_iter218 = this->properties.begin(); _iter218 != this->properties.end(); ++_iter218) { - xfer += oprot->writeString(_iter212->first); - xfer += oprot->writeString(_iter212->second); + xfer += oprot->writeString(_iter218->first); + xfer += oprot->writeString(_iter218->second); } xfer += oprot->writeMapEnd(); } @@ -4814,17 +4914,17 @@ uint32_t EnvironmentContext::read(::apac if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size213; - ::apache::thrift::protocol::TType _ktype214; - ::apache::thrift::protocol::TType _vtype215; - xfer += iprot->readMapBegin(_ktype214, _vtype215, _size213); - uint32_t _i217; - for (_i217 = 0; _i217 < _size213; ++_i217) + uint32_t _size219; + ::apache::thrift::protocol::TType _ktype220; + ::apache::thrift::protocol::TType _vtype221; + xfer += iprot->readMapBegin(_ktype220, _vtype221, _size219); + uint32_t _i223; + for (_i223 = 0; _i223 < _size219; ++_i223) { - std::string _key218; - xfer += iprot->readString(_key218); - std::string& _val219 = this->properties[_key218]; - xfer += iprot->readString(_val219); + std::string _key224; + xfer += iprot->readString(_key224); + std::string& _val225 = this->properties[_key224]; + xfer += iprot->readString(_val225); } xfer += iprot->readMapEnd(); } @@ -4852,11 +4952,11 @@ uint32_t EnvironmentContext::write(::apa xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size())); - std::map<std::string, std::string> ::const_iterator _iter220; - for (_iter220 = this->properties.begin(); _iter220 != this->properties.end(); ++_iter220) + std::map<std::string, std::string> ::const_iterator _iter226; + for (_iter226 = this->properties.begin(); _iter226 != this->properties.end(); ++_iter226) { - xfer += oprot->writeString(_iter220->first); - xfer += oprot->writeString(_iter220->second); + xfer += oprot->writeString(_iter226->first); + xfer += oprot->writeString(_iter226->second); } xfer += oprot->writeMapEnd(); } @@ -4902,14 +5002,14 @@ uint32_t PartitionsByExprResult::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size221; - ::apache::thrift::protocol::TType _etype224; - xfer += iprot->readListBegin(_etype224, _size221); - this->partitions.resize(_size221); - uint32_t _i225; - for (_i225 = 0; _i225 < _size221; ++_i225) + uint32_t _size227; + ::apache::thrift::protocol::TType _etype230; + xfer += iprot->readListBegin(_etype230, _size227); + this->partitions.resize(_size227); + uint32_t _i231; + for (_i231 = 0; _i231 < _size227; ++_i231) { - xfer += this->partitions[_i225].read(iprot); + xfer += this->partitions[_i231].read(iprot); } xfer += iprot->readListEnd(); } @@ -4949,10 +5049,10 @@ uint32_t PartitionsByExprResult::write(: xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); - std::vector<Partition> ::const_iterator _iter226; - for (_iter226 = this->partitions.begin(); _iter226 != this->partitions.end(); ++_iter226) + std::vector<Partition> ::const_iterator _iter232; + for (_iter232 = this->partitions.begin(); _iter232 != this->partitions.end(); ++_iter232) { - xfer += (*_iter226).write(oprot); + xfer += (*_iter232).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5126,14 +5226,14 @@ uint32_t TableStatsResult::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size227; - ::apache::thrift::protocol::TType _etype230; - xfer += iprot->readListBegin(_etype230, _size227); - this->tableStats.resize(_size227); - uint32_t _i231; - for (_i231 = 0; _i231 < _size227; ++_i231) + uint32_t _size233; + ::apache::thrift::protocol::TType _etype236; + xfer += iprot->readListBegin(_etype236, _size233); + this->tableStats.resize(_size233); + uint32_t _i237; + for (_i237 = 0; _i237 < _size233; ++_i237) { - xfer += this->tableStats[_i231].read(iprot); + xfer += this->tableStats[_i237].read(iprot); } xfer += iprot->readListEnd(); } @@ -5163,10 +5263,10 @@ uint32_t TableStatsResult::write(::apach xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tableStats.size())); - std::vector<ColumnStatisticsObj> ::const_iterator _iter232; - for (_iter232 = this->tableStats.begin(); _iter232 != this->tableStats.end(); ++_iter232) + std::vector<ColumnStatisticsObj> ::const_iterator _iter238; + for (_iter238 = this->tableStats.begin(); _iter238 != this->tableStats.end(); ++_iter238) { - xfer += (*_iter232).write(oprot); + xfer += (*_iter238).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5210,26 +5310,26 @@ uint32_t PartitionsStatsResult::read(::a if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size233; - ::apache::thrift::protocol::TType _ktype234; - ::apache::thrift::protocol::TType _vtype235; - xfer += iprot->readMapBegin(_ktype234, _vtype235, _size233); - uint32_t _i237; - for (_i237 = 0; _i237 < _size233; ++_i237) + uint32_t _size239; + ::apache::thrift::protocol::TType _ktype240; + ::apache::thrift::protocol::TType _vtype241; + xfer += iprot->readMapBegin(_ktype240, _vtype241, _size239); + uint32_t _i243; + for (_i243 = 0; _i243 < _size239; ++_i243) { - std::string _key238; - xfer += iprot->readString(_key238); - std::vector<ColumnStatisticsObj> & _val239 = this->partStats[_key238]; + std::string _key244; + xfer += iprot->readString(_key244); + std::vector<ColumnStatisticsObj> & _val245 = this->partStats[_key244]; { - _val239.clear(); - uint32_t _size240; - ::apache::thrift::protocol::TType _etype243; - xfer += iprot->readListBegin(_etype243, _size240); - _val239.resize(_size240); - uint32_t _i244; - for (_i244 = 0; _i244 < _size240; ++_i244) + _val245.clear(); + uint32_t _size246; + ::apache::thrift::protocol::TType _etype249; + xfer += iprot->readListBegin(_etype249, _size246); + _val245.resize(_size246); + uint32_t _i250; + for (_i250 = 0; _i250 < _size246; ++_i250) { - xfer += _val239[_i244].read(iprot); + xfer += _val245[_i250].read(iprot); } xfer += iprot->readListEnd(); } @@ -5262,16 +5362,16 @@ uint32_t PartitionsStatsResult::write(:: xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->partStats.size())); - std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter245; - for (_iter245 = this->partStats.begin(); _iter245 != this->partStats.end(); ++_iter245) + std::map<std::string, std::vector<ColumnStatisticsObj> > ::const_iterator _iter251; + for (_iter251 = this->partStats.begin(); _iter251 != this->partStats.end(); ++_iter251) { - xfer += oprot->writeString(_iter245->first); + xfer += oprot->writeString(_iter251->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter245->second.size())); - std::vector<ColumnStatisticsObj> ::const_iterator _iter246; - for (_iter246 = _iter245->second.begin(); _iter246 != _iter245->second.end(); ++_iter246) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter251->second.size())); + std::vector<ColumnStatisticsObj> ::const_iterator _iter252; + for (_iter252 = _iter251->second.begin(); _iter252 != _iter251->second.end(); ++_iter252) { - xfer += (*_iter246).write(oprot); + xfer += (*_iter252).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5336,14 +5436,14 @@ uint32_t TableStatsRequest::read(::apach if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size247; - ::apache::thrift::protocol::TType _etype250; - xfer += iprot->readListBegin(_etype250, _size247); - this->colNames.resize(_size247); - uint32_t _i251; - for (_i251 = 0; _i251 < _size247; ++_i251) + uint32_t _size253; + ::apache::thrift::protocol::TType _etype256; + xfer += iprot->readListBegin(_etype256, _size253); + this->colNames.resize(_size253); + uint32_t _i257; + for (_i257 = 0; _i257 < _size253; ++_i257) { - xfer += iprot->readString(this->colNames[_i251]); + xfer += iprot->readString(this->colNames[_i257]); } xfer += iprot->readListEnd(); } @@ -5385,10 +5485,10 @@ uint32_t TableStatsRequest::write(::apac xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size())); - std::vector<std::string> ::const_iterator _iter252; - for (_iter252 = this->colNames.begin(); _iter252 != this->colNames.end(); ++_iter252) + std::vector<std::string> ::const_iterator _iter258; + for (_iter258 = this->colNames.begin(); _iter258 != this->colNames.end(); ++_iter258) { - xfer += oprot->writeString((*_iter252)); + xfer += oprot->writeString((*_iter258)); } xfer += oprot->writeListEnd(); } @@ -5453,14 +5553,14 @@ uint32_t PartitionsStatsRequest::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size253; - ::apache::thrift::protocol::TType _etype256; - xfer += iprot->readListBegin(_etype256, _size253); - this->colNames.resize(_size253); - uint32_t _i257; - for (_i257 = 0; _i257 < _size253; ++_i257) + uint32_t _size259; + ::apache::thrift::protocol::TType _etype262; + xfer += iprot->readListBegin(_etype262, _size259); + this->colNames.resize(_size259); + uint32_t _i263; + for (_i263 = 0; _i263 < _size259; ++_i263) { - xfer += iprot->readString(this->colNames[_i257]); + xfer += iprot->readString(this->colNames[_i263]); } xfer += iprot->readListEnd(); } @@ -5473,14 +5573,14 @@ uint32_t PartitionsStatsRequest::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size258; - ::apache::thrift::protocol::TType _etype261; - xfer += iprot->readListBegin(_etype261, _size258); - this->partNames.resize(_size258); - uint32_t _i262; - for (_i262 = 0; _i262 < _size258; ++_i262) + uint32_t _size264; + ::apache::thrift::protocol::TType _etype267; + xfer += iprot->readListBegin(_etype267, _size264); + this->partNames.resize(_size264); + uint32_t _i268; + for (_i268 = 0; _i268 < _size264; ++_i268) { - xfer += iprot->readString(this->partNames[_i262]); + xfer += iprot->readString(this->partNames[_i268]); } xfer += iprot->readListEnd(); } @@ -5524,10 +5624,10 @@ uint32_t PartitionsStatsRequest::write(: xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->colNames.size())); - std::vector<std::string> ::const_iterator _iter263; - for (_iter263 = this->colNames.begin(); _iter263 != this->colNames.end(); ++_iter263) + std::vector<std::string> ::const_iterator _iter269; + for (_iter269 = this->colNames.begin(); _iter269 != this->colNames.end(); ++_iter269) { - xfer += oprot->writeString((*_iter263)); + xfer += oprot->writeString((*_iter269)); } xfer += oprot->writeListEnd(); } @@ -5536,10 +5636,10 @@ uint32_t PartitionsStatsRequest::write(: xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); - std::vector<std::string> ::const_iterator _iter264; - for (_iter264 = this->partNames.begin(); _iter264 != this->partNames.end(); ++_iter264) + std::vector<std::string> ::const_iterator _iter270; + for (_iter270 = this->partNames.begin(); _iter270 != this->partNames.end(); ++_iter270) { - xfer += oprot->writeString((*_iter264)); + xfer += oprot->writeString((*_iter270)); } xfer += oprot->writeListEnd(); } @@ -5585,14 +5685,14 @@ uint32_t AddPartitionsResult::read(::apa if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size265; - ::apache::thrift::protocol::TType _etype268; - xfer += iprot->readListBegin(_etype268, _size265); - this->partitions.resize(_size265); - uint32_t _i269; - for (_i269 = 0; _i269 < _size265; ++_i269) + uint32_t _size271; + ::apache::thrift::protocol::TType _etype274; + xfer += iprot->readListBegin(_etype274, _size271); + this->partitions.resize(_size271); + uint32_t _i275; + for (_i275 = 0; _i275 < _size271; ++_i275) { - xfer += this->partitions[_i269].read(iprot); + xfer += this->partitions[_i275].read(iprot); } xfer += iprot->readListEnd(); } @@ -5621,10 +5721,10 @@ uint32_t AddPartitionsResult::write(::ap xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); - std::vector<Partition> ::const_iterator _iter270; - for (_iter270 = this->partitions.begin(); _iter270 != this->partitions.end(); ++_iter270) + std::vector<Partition> ::const_iterator _iter276; + for (_iter276 = this->partitions.begin(); _iter276 != this->partitions.end(); ++_iter276) { - xfer += (*_iter270).write(oprot); + xfer += (*_iter276).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5688,14 +5788,14 @@ uint32_t AddPartitionsRequest::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size271; - ::apache::thrift::protocol::TType _etype274; - xfer += iprot->readListBegin(_etype274, _size271); - this->parts.resize(_size271); - uint32_t _i275; - for (_i275 = 0; _i275 < _size271; ++_i275) + uint32_t _size277; + ::apache::thrift::protocol::TType _etype280; + xfer += iprot->readListBegin(_etype280, _size277); + this->parts.resize(_size277); + uint32_t _i281; + for (_i281 = 0; _i281 < _size277; ++_i281) { - xfer += this->parts[_i275].read(iprot); + xfer += this->parts[_i281].read(iprot); } xfer += iprot->readListEnd(); } @@ -5755,10 +5855,10 @@ uint32_t AddPartitionsRequest::write(::a xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->parts.size())); - std::vector<Partition> ::const_iterator _iter276; - for (_iter276 = this->parts.begin(); _iter276 != this->parts.end(); ++_iter276) + std::vector<Partition> ::const_iterator _iter282; + for (_iter282 = this->parts.begin(); _iter282 != this->parts.end(); ++_iter282) { - xfer += (*_iter276).write(oprot); + xfer += (*_iter282).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5815,14 +5915,14 @@ uint32_t DropPartitionsResult::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size277; - ::apache::thrift::protocol::TType _etype280; - xfer += iprot->readListBegin(_etype280, _size277); - this->partitions.resize(_size277); - uint32_t _i281; - for (_i281 = 0; _i281 < _size277; ++_i281) + uint32_t _size283; + ::apache::thrift::protocol::TType _etype286; + xfer += iprot->readListBegin(_etype286, _size283); + this->partitions.resize(_size283); + uint32_t _i287; + for (_i287 = 0; _i287 < _size283; ++_i287) { - xfer += this->partitions[_i281].read(iprot); + xfer += this->partitions[_i287].read(iprot); } xfer += iprot->readListEnd(); } @@ -5851,10 +5951,10 @@ uint32_t DropPartitionsResult::write(::a xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size())); - std::vector<Partition> ::const_iterator _iter282; - for (_iter282 = this->partitions.begin(); _iter282 != this->partitions.end(); ++_iter282) + std::vector<Partition> ::const_iterator _iter288; + for (_iter288 = this->partitions.begin(); _iter288 != this->partitions.end(); ++_iter288) { - xfer += (*_iter282).write(oprot); + xfer += (*_iter288).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5977,14 +6077,14 @@ uint32_t RequestPartsSpec::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size283; - ::apache::thrift::protocol::TType _etype286; - xfer += iprot->readListBegin(_etype286, _size283); - this->names.resize(_size283); - uint32_t _i287; - for (_i287 = 0; _i287 < _size283; ++_i287) + uint32_t _size289; + ::apache::thrift::protocol::TType _etype292; + xfer += iprot->readListBegin(_etype292, _size289); + this->names.resize(_size289); + uint32_t _i293; + for (_i293 = 0; _i293 < _size289; ++_i293) { - xfer += iprot->readString(this->names[_i287]); + xfer += iprot->readString(this->names[_i293]); } xfer += iprot->readListEnd(); } @@ -5997,14 +6097,14 @@ uint32_t RequestPartsSpec::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size288; - ::apache::thrift::protocol::TType _etype291; - xfer += iprot->readListBegin(_etype291, _size288); - this->exprs.resize(_size288); - uint32_t _i292; - for (_i292 = 0; _i292 < _size288; ++_i292) + uint32_t _size294; + ::apache::thrift::protocol::TType _etype297; + xfer += iprot->readListBegin(_etype297, _size294); + this->exprs.resize(_size294); + uint32_t _i298; + for (_i298 = 0; _i298 < _size294; ++_i298) { - xfer += this->exprs[_i292].read(iprot); + xfer += this->exprs[_i298].read(iprot); } xfer += iprot->readListEnd(); } @@ -6032,10 +6132,10 @@ uint32_t RequestPartsSpec::write(::apach xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size())); - std::vector<std::string> ::const_iterator _iter293; - for (_iter293 = this->names.begin(); _iter293 != this->names.end(); ++_iter293) + std::vector<std::string> ::const_iterator _iter299; + for (_iter299 = this->names.begin(); _iter299 != this->names.end(); ++_iter299) { - xfer += oprot->writeString((*_iter293)); + xfer += oprot->writeString((*_iter299)); } xfer += oprot->writeListEnd(); } @@ -6044,10 +6144,10 @@ uint32_t RequestPartsSpec::write(::apach xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->exprs.size())); - std::vector<DropPartitionsExpr> ::const_iterator _iter294; - for (_iter294 = this->exprs.begin(); _iter294 != this->exprs.end(); ++_iter294) + std::vector<DropPartitionsExpr> ::const_iterator _iter300; + for (_iter300 = this->exprs.begin(); _iter300 != this->exprs.end(); ++_iter300) { - xfer += (*_iter294).write(oprot); + xfer += (*_iter300).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6257,9 +6357,9 @@ uint32_t ResourceUri::read(::apache::thr { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast295; - xfer += iprot->readI32(ecast295); - this->resourceType = (ResourceType::type)ecast295; + int32_t ecast301; + xfer += iprot->readI32(ecast301); + this->resourceType = (ResourceType::type)ecast301; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -6366,9 +6466,9 @@ uint32_t Function::read(::apache::thrift break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast296; - xfer += iprot->readI32(ecast296); - this->ownerType = (PrincipalType::type)ecast296; + int32_t ecast302; + xfer += iprot->readI32(ecast302); + this->ownerType = (PrincipalType::type)ecast302; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -6384,9 +6484,9 @@ uint32_t Function::read(::apache::thrift break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast297; - xfer += iprot->readI32(ecast297); - this->functionType = (FunctionType::type)ecast297; + int32_t ecast303; + xfer += iprot->readI32(ecast303); + this->functionType = (FunctionType::type)ecast303; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -6396,14 +6496,14 @@ uint32_t Function::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size298; - ::apache::thrift::protocol::TType _etype301; - xfer += iprot->readListBegin(_etype301, _size298); - this->resourceUris.resize(_size298); - uint32_t _i302; - for (_i302 = 0; _i302 < _size298; ++_i302) + uint32_t _size304; + ::apache::thrift::protocol::TType _etype307; + xfer += iprot->readListBegin(_etype307, _size304); + this->resourceUris.resize(_size304); + uint32_t _i308; + for (_i308 = 0; _i308 < _size304; ++_i308) { - xfer += this->resourceUris[_i302].read(iprot); + xfer += this->resourceUris[_i308].read(iprot); } xfer += iprot->readListEnd(); } @@ -6459,10 +6559,10 @@ uint32_t Function::write(::apache::thrif xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->resourceUris.size())); - std::vector<ResourceUri> ::const_iterator _iter303; - for (_iter303 = this->resourceUris.begin(); _iter303 != this->resourceUris.end(); ++_iter303) + std::vector<ResourceUri> ::const_iterator _iter309; + for (_iter309 = this->resourceUris.begin(); _iter309 != this->resourceUris.end(); ++_iter309) { - xfer += (*_iter303).write(oprot); + xfer += (*_iter309).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6523,9 +6623,9 @@ uint32_t TxnInfo::read(::apache::thrift: break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast304; - xfer += iprot->readI32(ecast304); - this->state = (TxnState::type)ecast304; + int32_t ecast310; + xfer += iprot->readI32(ecast310); + this->state = (TxnState::type)ecast310; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -6637,14 +6737,14 @@ uint32_t GetOpenTxnsInfoResponse::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size305; - ::apache::thrift::protocol::TType _etype308; - xfer += iprot->readListBegin(_etype308, _size305); - this->open_txns.resize(_size305); - uint32_t _i309; - for (_i309 = 0; _i309 < _size305; ++_i309) + uint32_t _size311; + ::apache::thrift::protocol::TType _etype314; + xfer += iprot->readListBegin(_etype314, _size311); + this->open_txns.resize(_size311); + uint32_t _i315; + for (_i315 = 0; _i315 < _size311; ++_i315) { - xfer += this->open_txns[_i309].read(iprot); + xfer += this->open_txns[_i315].read(iprot); } xfer += iprot->readListEnd(); } @@ -6680,10 +6780,10 @@ uint32_t GetOpenTxnsInfoResponse::write( xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->open_txns.size())); - std::vector<TxnInfo> ::const_iterator _iter310; - for (_iter310 = this->open_txns.begin(); _iter310 != this->open_txns.end(); ++_iter310) + std::vector<TxnInfo> ::const_iterator _iter316; + for (_iter316 = this->open_txns.begin(); _iter316 != this->open_txns.end(); ++_iter316) { - xfer += (*_iter310).write(oprot); + xfer += (*_iter316).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6737,15 +6837,15 @@ uint32_t GetOpenTxnsResponse::read(::apa if (ftype == ::apache::thrift::protocol::T_SET) { { this->open_txns.clear(); - uint32_t _size311; - ::apache::thrift::protocol::TType _etype314; - xfer += iprot->readSetBegin(_etype314, _size311); - uint32_t _i315; - for (_i315 = 0; _i315 < _size311; ++_i315) + uint32_t _size317; + ::apache::thrift::protocol::TType _etype320; + xfer += iprot->readSetBegin(_etype320, _size317); + uint32_t _i321; + for (_i321 = 0; _i321 < _size317; ++_i321) { - int64_t _elem316; - xfer += iprot->readI64(_elem316); - this->open_txns.insert(_elem316); + int64_t _elem322; + xfer += iprot->readI64(_elem322); + this->open_txns.insert(_elem322); } xfer += iprot->readSetEnd(); } @@ -6781,10 +6881,10 @@ uint32_t GetOpenTxnsResponse::write(::ap xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->open_txns.size())); - std::set<int64_t> ::const_iterator _iter317; - for (_iter317 = this->open_txns.begin(); _iter317 != this->open_txns.end(); ++_iter317) + std::set<int64_t> ::const_iterator _iter323; + for (_iter323 = this->open_txns.begin(); _iter323 != this->open_txns.end(); ++_iter323) { - xfer += oprot->writeI64((*_iter317)); + xfer += oprot->writeI64((*_iter323)); } xfer += oprot->writeSetEnd(); } @@ -6925,14 +7025,14 @@ uint32_t OpenTxnsResponse::read(::apache if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size318; - ::apache::thrift::protocol::TType _etype321; - xfer += iprot->readListBegin(_etype321, _size318); - this->txn_ids.resize(_size318); - uint32_t _i322; - for (_i322 = 0; _i322 < _size318; ++_i322) + uint32_t _size324; + ::apache::thrift::protocol::TType _etype327; + xfer += iprot->readListBegin(_etype327, _size324); + this->txn_ids.resize(_size324); + uint32_t _i328; + for (_i328 = 0; _i328 < _size324; ++_i328) { - xfer += iprot->readI64(this->txn_ids[_i322]); + xfer += iprot->readI64(this->txn_ids[_i328]); } xfer += iprot->readListEnd(); } @@ -6962,10 +7062,10 @@ uint32_t OpenTxnsResponse::write(::apach xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->txn_ids.size())); - std::vector<int64_t> ::const_iterator _iter323; - for (_iter323 = this->txn_ids.begin(); _iter323 != this->txn_ids.end(); ++_iter323) + std::vector<int64_t> ::const_iterator _iter329; + for (_iter329 = this->txn_ids.begin(); _iter329 != this->txn_ids.end(); ++_iter329) { - xfer += oprot->writeI64((*_iter323)); + xfer += oprot->writeI64((*_iter329)); } xfer += oprot->writeListEnd(); } @@ -7137,9 +7237,9 @@ uint32_t LockComponent::read(::apache::t { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast324; - xfer += iprot->readI32(ecast324); - this->type = (LockType::type)ecast324; + int32_t ecast330; + xfer += iprot->readI32(ecast330); + this->type = (LockType::type)ecast330; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -7147,9 +7247,9 @@ uint32_t LockComponent::read(::apache::t break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast325; - xfer += iprot->readI32(ecast325); - this->level = (LockLevel::type)ecast325; + int32_t ecast331; + xfer += iprot->readI32(ecast331); + this->level = (LockLevel::type)ecast331; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -7268,14 +7368,14 @@ uint32_t LockRequest::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size326; - ::apache::thrift::protocol::TType _etype329; - xfer += iprot->readListBegin(_etype329, _size326); - this->component.resize(_size326); - uint32_t _i330; - for (_i330 = 0; _i330 < _size326; ++_i330) + uint32_t _size332; + ::apache::thrift::protocol::TType _etype335; + xfer += iprot->readListBegin(_etype335, _size332); + this->component.resize(_size332); + uint32_t _i336; + for (_i336 = 0; _i336 < _size332; ++_i336) { - xfer += this->component[_i330].read(iprot); + xfer += this->component[_i336].read(iprot); } xfer += iprot->readListEnd(); } @@ -7333,10 +7433,10 @@ uint32_t LockRequest::write(::apache::th xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->component.size())); - std::vector<LockComponent> ::const_iterator _iter331; - for (_iter331 = this->component.begin(); _iter331 != this->component.end(); ++_iter331) + std::vector<LockComponent> ::const_iterator _iter337; + for (_iter337 = this->component.begin(); _iter337 != this->component.end(); ++_iter337) { - xfer += (*_iter331).write(oprot); + xfer += (*_iter337).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7404,9 +7504,9 @@ uint32_t LockResponse::read(::apache::th break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast332; - xfer += iprot->readI32(ecast332); - this->state = (LockState::type)ecast332; + int32_t ecast338; + xfer += iprot->readI32(ecast338); + this->state = (LockState::type)ecast338; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -7688,9 +7788,9 @@ uint32_t ShowLocksResponseElement::read( break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast333; - xfer += iprot->readI32(ecast333); - this->state = (LockState::type)ecast333; + int32_t ecast339; + xfer += iprot->readI32(ecast339); + this->state = (LockState::type)ecast339; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -7698,9 +7798,9 @@ uint32_t ShowLocksResponseElement::read( break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast334; - xfer += iprot->readI32(ecast334); - this->type = (LockType::type)ecast334; + int32_t ecast340; + xfer += iprot->readI32(ecast340); + this->type = (LockType::type)ecast340; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -7872,14 +7972,14 @@ uint32_t ShowLocksResponse::read(::apach if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size335; - ::apache::thrift::protocol::TType _etype338; - xfer += iprot->readListBegin(_etype338, _size335); - this->locks.resize(_size335); - uint32_t _i339; - for (_i339 = 0; _i339 < _size335; ++_i339) + uint32_t _size341; + ::apache::thrift::protocol::TType _etype344; + xfer += iprot->readListBegin(_etype344, _size341); + this->locks.resize(_size341); + uint32_t _i345; + for (_i345 = 0; _i345 < _size341; ++_i345) { - xfer += this->locks[_i339].read(iprot); + xfer += this->locks[_i345].read(iprot); } xfer += iprot->readListEnd(); } @@ -7907,10 +8007,10 @@ uint32_t ShowLocksResponse::write(::apac xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->locks.size())); - std::vector<ShowLocksResponseElement> ::const_iterator _iter340; - for (_iter340 = this->locks.begin(); _iter340 != this->locks.end(); ++_iter340) + std::vector<ShowLocksResponseElement> ::const_iterator _iter346; + for (_iter346 = this->locks.begin(); _iter346 != this->locks.end(); ++_iter346) { - xfer += (*_iter340).write(oprot); + xfer += (*_iter346).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8113,15 +8213,15 @@ uint32_t HeartbeatTxnRangeResponse::read if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size341; - ::apache::thrift::protocol::TType _etype344; - xfer += iprot->readSetBegin(_etype344, _size341); - uint32_t _i345; - for (_i345 = 0; _i345 < _size341; ++_i345) + uint32_t _size347; + ::apache::thrift::protocol::TType _etype350; + xfer += iprot->readSetBegin(_etype350, _size347); + uint32_t _i351; + for (_i351 = 0; _i351 < _size347; ++_i351) { - int64_t _elem346; - xfer += iprot->readI64(_elem346); - this->aborted.insert(_elem346); + int64_t _elem352; + xfer += iprot->readI64(_elem352); + this->aborted.insert(_elem352); } xfer += iprot->readSetEnd(); } @@ -8134,15 +8234,15 @@ uint32_t HeartbeatTxnRangeResponse::read if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size347; - ::apache::thrift::protocol::TType _etype350; - xfer += iprot->readSetBegin(_etype350, _size347); - uint32_t _i351; - for (_i351 = 0; _i351 < _size347; ++_i351) + uint32_t _size353; + ::apache::thrift::protocol::TType _etype356; + xfer += iprot->readSetBegin(_etype356, _size353); + uint32_t _i357; + for (_i357 = 0; _i357 < _size353; ++_i357) { - int64_t _elem352; - xfer += iprot->readI64(_elem352); - this->nosuch.insert(_elem352); + int64_t _elem358; + xfer += iprot->readI64(_elem358); + this->nosuch.insert(_elem358); } xfer += iprot->readSetEnd(); } @@ -8174,10 +8274,10 @@ uint32_t HeartbeatTxnRangeResponse::writ xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->aborted.size())); - std::set<int64_t> ::const_iterator _iter353; - for (_iter353 = this->aborted.begin(); _iter353 != this->aborted.end(); ++_iter353) + std::set<int64_t> ::const_iterator _iter359; + for (_iter359 = this->aborted.begin(); _iter359 != this->aborted.end(); ++_iter359) { - xfer += oprot->writeI64((*_iter353)); + xfer += oprot->writeI64((*_iter359)); } xfer += oprot->writeSetEnd(); } @@ -8186,10 +8286,10 @@ uint32_t HeartbeatTxnRangeResponse::writ xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->nosuch.size())); - std::set<int64_t> ::const_iterator _iter354; - for (_iter354 = this->nosuch.begin(); _iter354 != this->nosuch.end(); ++_iter354) + std::set<int64_t> ::const_iterator _iter360; + for (_iter360 = this->nosuch.begin(); _iter360 != this->nosuch.end(); ++_iter360) { - xfer += oprot->writeI64((*_iter354)); + xfer += oprot->writeI64((*_iter360)); } xfer += oprot->writeSetEnd(); } @@ -8258,9 +8358,9 @@ uint32_t CompactionRequest::read(::apach break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast355; - xfer += iprot->readI32(ecast355); - this->type = (CompactionType::type)ecast355; + int32_t ecast361; + xfer += iprot->readI32(ecast361); + this->type = (CompactionType::type)ecast361; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -8435,9 +8535,9 @@ uint32_t ShowCompactResponseElement::rea break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast356; - xfer += iprot->readI32(ecast356); - this->type = (CompactionType::type)ecast356; + int32_t ecast362; + xfer += iprot->readI32(ecast362); + this->type = (CompactionType::type)ecast362; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -8584,14 +8684,14 @@ uint32_t ShowCompactResponse::read(::apa if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size357; - ::apache::thrift::protocol::TType _etype360; - xfer += iprot->readListBegin(_etype360, _size357); - this->compacts.resize(_size357); - uint32_t _i361; - for (_i361 = 0; _i361 < _size357; ++_i361) + uint32_t _size363; + ::apache::thrift::protocol::TType _etype366; + xfer += iprot->readListBegin(_etype366, _size363); + this->compacts.resize(_size363); + uint32_t _i367; + for (_i367 = 0; _i367 < _size363; ++_i367) { - xfer += this->compacts[_i361].read(iprot); + xfer += this->compacts[_i367].read(iprot); } xfer += iprot->readListEnd(); } @@ -8621,10 +8721,10 @@ uint32_t ShowCompactResponse::write(::ap 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 _iter362; - for (_iter362 = this->compacts.begin(); _iter362 != this->compacts.end(); ++_iter362) + std::vector<ShowCompactResponseElement> ::const_iterator _iter368; + for (_iter368 = this->compacts.begin(); _iter368 != this->compacts.end(); ++_iter368) { - xfer += (*_iter362).write(oprot); + xfer += (*_iter368).write(oprot); } xfer += oprot->writeListEnd(); } Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original) +++ hive/trunk/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Tue Aug 5 05:52:51 2014 @@ -2637,6 +2637,50 @@ class ColumnStatistics { void swap(ColumnStatistics &a, ColumnStatistics &b); + +class AggrStats { + public: + + static const char* ascii_fingerprint; // = "399BDBAF7503E0BFB5E1D99C83D790CD"; + static const uint8_t binary_fingerprint[16]; // = {0x39,0x9B,0xDB,0xAF,0x75,0x03,0xE0,0xBF,0xB5,0xE1,0xD9,0x9C,0x83,0xD7,0x90,0xCD}; + + AggrStats() : partsFound(0) { + } + + virtual ~AggrStats() throw() {} + + std::vector<ColumnStatisticsObj> colStats; + int64_t partsFound; + + void __set_colStats(const std::vector<ColumnStatisticsObj> & val) { + colStats = val; + } + + void __set_partsFound(const int64_t val) { + partsFound = val; + } + + bool operator == (const AggrStats & rhs) const + { + if (!(colStats == rhs.colStats)) + return false; + if (!(partsFound == rhs.partsFound)) + return false; + return true; + } + bool operator != (const AggrStats &rhs) const { + return !(*this == rhs); + } + + bool operator < (const AggrStats & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +void swap(AggrStats &a, AggrStats &b); + typedef struct _Schema__isset { _Schema__isset() : fieldSchemas(false), properties(false) {} bool fieldSchemas; Modified: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java (original) +++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsRequest.java Tue Aug 5 05:52:51 2014 @@ -700,14 +700,14 @@ public class AddPartitionsRequest implem case 3: // PARTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list338 = iprot.readListBegin(); - struct.parts = new ArrayList<Partition>(_list338.size); - for (int _i339 = 0; _i339 < _list338.size; ++_i339) + org.apache.thrift.protocol.TList _list346 = iprot.readListBegin(); + struct.parts = new ArrayList<Partition>(_list346.size); + for (int _i347 = 0; _i347 < _list346.size; ++_i347) { - Partition _elem340; // optional - _elem340 = new Partition(); - _elem340.read(iprot); - struct.parts.add(_elem340); + Partition _elem348; // required + _elem348 = new Partition(); + _elem348.read(iprot); + struct.parts.add(_elem348); } iprot.readListEnd(); } @@ -759,9 +759,9 @@ public class AddPartitionsRequest implem oprot.writeFieldBegin(PARTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.parts.size())); - for (Partition _iter341 : struct.parts) + for (Partition _iter349 : struct.parts) { - _iter341.write(oprot); + _iter349.write(oprot); } oprot.writeListEnd(); } @@ -796,9 +796,9 @@ public class AddPartitionsRequest implem oprot.writeString(struct.tblName); { oprot.writeI32(struct.parts.size()); - for (Partition _iter342 : struct.parts) + for (Partition _iter350 : struct.parts) { - _iter342.write(oprot); + _iter350.write(oprot); } } oprot.writeBool(struct.ifNotExists); @@ -820,14 +820,14 @@ public class AddPartitionsRequest implem struct.tblName = iprot.readString(); struct.setTblNameIsSet(true); { - org.apache.thrift.protocol.TList _list343 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.parts = new ArrayList<Partition>(_list343.size); - for (int _i344 = 0; _i344 < _list343.size; ++_i344) + org.apache.thrift.protocol.TList _list351 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.parts = new ArrayList<Partition>(_list351.size); + for (int _i352 = 0; _i352 < _list351.size; ++_i352) { - Partition _elem345; // optional - _elem345 = new Partition(); - _elem345.read(iprot); - struct.parts.add(_elem345); + Partition _elem353; // required + _elem353 = new Partition(); + _elem353.read(iprot); + struct.parts.add(_elem353); } } struct.setPartsIsSet(true); Modified: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java?rev=1615865&r1=1615864&r2=1615865&view=diff ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java (original) +++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AddPartitionsResult.java Tue Aug 5 05:52:51 2014 @@ -342,14 +342,14 @@ public class AddPartitionsResult impleme case 1: // PARTITIONS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list330 = iprot.readListBegin(); - struct.partitions = new ArrayList<Partition>(_list330.size); - for (int _i331 = 0; _i331 < _list330.size; ++_i331) + org.apache.thrift.protocol.TList _list338 = iprot.readListBegin(); + struct.partitions = new ArrayList<Partition>(_list338.size); + for (int _i339 = 0; _i339 < _list338.size; ++_i339) { - Partition _elem332; // optional - _elem332 = new Partition(); - _elem332.read(iprot); - struct.partitions.add(_elem332); + Partition _elem340; // required + _elem340 = new Partition(); + _elem340.read(iprot); + struct.partitions.add(_elem340); } iprot.readListEnd(); } @@ -376,9 +376,9 @@ public class AddPartitionsResult impleme oprot.writeFieldBegin(PARTITIONS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitions.size())); - for (Partition _iter333 : struct.partitions) + for (Partition _iter341 : struct.partitions) { - _iter333.write(oprot); + _iter341.write(oprot); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public class AddPartitionsResult impleme if (struct.isSetPartitions()) { { oprot.writeI32(struct.partitions.size()); - for (Partition _iter334 : struct.partitions) + for (Partition _iter342 : struct.partitions) { - _iter334.write(oprot); + _iter342.write(oprot); } } } @@ -424,14 +424,14 @@ public class AddPartitionsResult impleme BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { { - org.apache.thrift.protocol.TList _list335 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.partitions = new ArrayList<Partition>(_list335.size); - for (int _i336 = 0; _i336 < _list335.size; ++_i336) + org.apache.thrift.protocol.TList _list343 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.partitions = new ArrayList<Partition>(_list343.size); + for (int _i344 = 0; _i344 < _list343.size; ++_i344) { - Partition _elem337; // optional - _elem337 = new Partition(); - _elem337.read(iprot); - struct.partitions.add(_elem337); + Partition _elem345; // required + _elem345 = new Partition(); + _elem345.read(iprot); + struct.partitions.add(_elem345); } } struct.setPartitionsIsSet(true); Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AggrStats.java URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AggrStats.java?rev=1615865&view=auto ============================================================================== --- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AggrStats.java (added) +++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AggrStats.java Tue Aug 5 05:52:51 2014 @@ -0,0 +1,538 @@ +/** + * Autogenerated by Thrift Compiler (0.9.0) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.commons.lang.builder.HashCodeBuilder; +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class AggrStats implements org.apache.thrift.TBase<AggrStats, AggrStats._Fields>, java.io.Serializable, Cloneable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AggrStats"); + + private static final org.apache.thrift.protocol.TField COL_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("colStats", org.apache.thrift.protocol.TType.LIST, (short)1); + private static final org.apache.thrift.protocol.TField PARTS_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("partsFound", org.apache.thrift.protocol.TType.I64, (short)2); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new AggrStatsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new AggrStatsTupleSchemeFactory()); + } + + private List<ColumnStatisticsObj> colStats; // required + private long partsFound; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + COL_STATS((short)1, "colStats"), + PARTS_FOUND((short)2, "partsFound"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // COL_STATS + return COL_STATS; + case 2: // PARTS_FOUND + return PARTS_FOUND; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PARTSFOUND_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.COL_STATS, new org.apache.thrift.meta_data.FieldMetaData("colStats", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatisticsObj.class)))); + tmpMap.put(_Fields.PARTS_FOUND, new org.apache.thrift.meta_data.FieldMetaData("partsFound", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AggrStats.class, metaDataMap); + } + + public AggrStats() { + } + + public AggrStats( + List<ColumnStatisticsObj> colStats, + long partsFound) + { + this(); + this.colStats = colStats; + this.partsFound = partsFound; + setPartsFoundIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public AggrStats(AggrStats other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetColStats()) { + List<ColumnStatisticsObj> __this__colStats = new ArrayList<ColumnStatisticsObj>(); + for (ColumnStatisticsObj other_element : other.colStats) { + __this__colStats.add(new ColumnStatisticsObj(other_element)); + } + this.colStats = __this__colStats; + } + this.partsFound = other.partsFound; + } + + public AggrStats deepCopy() { + return new AggrStats(this); + } + + @Override + public void clear() { + this.colStats = null; + setPartsFoundIsSet(false); + this.partsFound = 0; + } + + public int getColStatsSize() { + return (this.colStats == null) ? 0 : this.colStats.size(); + } + + public java.util.Iterator<ColumnStatisticsObj> getColStatsIterator() { + return (this.colStats == null) ? null : this.colStats.iterator(); + } + + public void addToColStats(ColumnStatisticsObj elem) { + if (this.colStats == null) { + this.colStats = new ArrayList<ColumnStatisticsObj>(); + } + this.colStats.add(elem); + } + + public List<ColumnStatisticsObj> getColStats() { + return this.colStats; + } + + public void setColStats(List<ColumnStatisticsObj> colStats) { + this.colStats = colStats; + } + + public void unsetColStats() { + this.colStats = null; + } + + /** Returns true if field colStats is set (has been assigned a value) and false otherwise */ + public boolean isSetColStats() { + return this.colStats != null; + } + + public void setColStatsIsSet(boolean value) { + if (!value) { + this.colStats = null; + } + } + + public long getPartsFound() { + return this.partsFound; + } + + public void setPartsFound(long partsFound) { + this.partsFound = partsFound; + setPartsFoundIsSet(true); + } + + public void unsetPartsFound() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PARTSFOUND_ISSET_ID); + } + + /** Returns true if field partsFound is set (has been assigned a value) and false otherwise */ + public boolean isSetPartsFound() { + return EncodingUtils.testBit(__isset_bitfield, __PARTSFOUND_ISSET_ID); + } + + public void setPartsFoundIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PARTSFOUND_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case COL_STATS: + if (value == null) { + unsetColStats(); + } else { + setColStats((List<ColumnStatisticsObj>)value); + } + break; + + case PARTS_FOUND: + if (value == null) { + unsetPartsFound(); + } else { + setPartsFound((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case COL_STATS: + return getColStats(); + + case PARTS_FOUND: + return Long.valueOf(getPartsFound()); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case COL_STATS: + return isSetColStats(); + case PARTS_FOUND: + return isSetPartsFound(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof AggrStats) + return this.equals((AggrStats)that); + return false; + } + + public boolean equals(AggrStats that) { + if (that == null) + return false; + + boolean this_present_colStats = true && this.isSetColStats(); + boolean that_present_colStats = true && that.isSetColStats(); + if (this_present_colStats || that_present_colStats) { + if (!(this_present_colStats && that_present_colStats)) + return false; + if (!this.colStats.equals(that.colStats)) + return false; + } + + boolean this_present_partsFound = true; + boolean that_present_partsFound = true; + if (this_present_partsFound || that_present_partsFound) { + if (!(this_present_partsFound && that_present_partsFound)) + return false; + if (this.partsFound != that.partsFound) + return false; + } + + return true; + } + + @Override + public int hashCode() { + HashCodeBuilder builder = new HashCodeBuilder(); + + boolean present_colStats = true && (isSetColStats()); + builder.append(present_colStats); + if (present_colStats) + builder.append(colStats); + + boolean present_partsFound = true; + builder.append(present_partsFound); + if (present_partsFound) + builder.append(partsFound); + + return builder.toHashCode(); + } + + public int compareTo(AggrStats other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + AggrStats typedOther = (AggrStats)other; + + lastComparison = Boolean.valueOf(isSetColStats()).compareTo(typedOther.isSetColStats()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColStats()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colStats, typedOther.colStats); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPartsFound()).compareTo(typedOther.isSetPartsFound()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartsFound()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partsFound, typedOther.partsFound); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("AggrStats("); + boolean first = true; + + sb.append("colStats:"); + if (this.colStats == null) { + sb.append("null"); + } else { + sb.append(this.colStats); + } + first = false; + if (!first) sb.append(", "); + sb.append("partsFound:"); + sb.append(this.partsFound); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetColStats()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'colStats' is unset! Struct:" + toString()); + } + + if (!isSetPartsFound()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'partsFound' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class AggrStatsStandardSchemeFactory implements SchemeFactory { + public AggrStatsStandardScheme getScheme() { + return new AggrStatsStandardScheme(); + } + } + + private static class AggrStatsStandardScheme extends StandardScheme<AggrStats> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, AggrStats struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // COL_STATS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list244 = iprot.readListBegin(); + struct.colStats = new ArrayList<ColumnStatisticsObj>(_list244.size); + for (int _i245 = 0; _i245 < _list244.size; ++_i245) + { + ColumnStatisticsObj _elem246; // required + _elem246 = new ColumnStatisticsObj(); + _elem246.read(iprot); + struct.colStats.add(_elem246); + } + iprot.readListEnd(); + } + struct.setColStatsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PARTS_FOUND + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.partsFound = iprot.readI64(); + struct.setPartsFoundIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, AggrStats struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.colStats != null) { + oprot.writeFieldBegin(COL_STATS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.colStats.size())); + for (ColumnStatisticsObj _iter247 : struct.colStats) + { + _iter247.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PARTS_FOUND_FIELD_DESC); + oprot.writeI64(struct.partsFound); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class AggrStatsTupleSchemeFactory implements SchemeFactory { + public AggrStatsTupleScheme getScheme() { + return new AggrStatsTupleScheme(); + } + } + + private static class AggrStatsTupleScheme extends TupleScheme<AggrStats> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, AggrStats struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + { + oprot.writeI32(struct.colStats.size()); + for (ColumnStatisticsObj _iter248 : struct.colStats) + { + _iter248.write(oprot); + } + } + oprot.writeI64(struct.partsFound); + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, AggrStats struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + { + org.apache.thrift.protocol.TList _list249 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.colStats = new ArrayList<ColumnStatisticsObj>(_list249.size); + for (int _i250 = 0; _i250 < _list249.size; ++_i250) + { + ColumnStatisticsObj _elem251; // required + _elem251 = new ColumnStatisticsObj(); + _elem251.read(iprot); + struct.colStats.add(_elem251); + } + } + struct.setColStatsIsSet(true); + struct.partsFound = iprot.readI64(); + struct.setPartsFoundIsSet(true); + } + } + +} +
