You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by gu...@apache.org on 2014/01/30 01:24:29 UTC
svn commit: r1562653 [3/10] - in /hive/trunk:
itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/
metastore/if/ metastore/src/gen/thrift/gen-cpp/
metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/
metastore/src/gen...
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=1562653&r1=1562652&r2=1562653&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Thu Jan 30 00:24:28 2014
@@ -84,6 +84,8 @@ class ThriftHiveMetastoreIf : virtual pu
virtual bool update_partition_column_statistics(const ColumnStatistics& stats_obj) = 0;
virtual void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0;
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 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 bool create_role(const Role& role) = 0;
@@ -345,6 +347,12 @@ class ThriftHiveMetastoreNull : 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 */) {
return;
}
+ void get_table_statistics_req(TableStatsResult& /* _return */, const TableStatsRequest& /* request */) {
+ return;
+ }
+ void get_partitions_statistics_req(PartitionsStatsResult& /* _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;
@@ -10276,6 +10284,262 @@ class ThriftHiveMetastore_get_partition_
};
+typedef struct _ThriftHiveMetastore_get_table_statistics_req_args__isset {
+ _ThriftHiveMetastore_get_table_statistics_req_args__isset() : request(false) {}
+ bool request;
+} _ThriftHiveMetastore_get_table_statistics_req_args__isset;
+
+class ThriftHiveMetastore_get_table_statistics_req_args {
+ public:
+
+ ThriftHiveMetastore_get_table_statistics_req_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_statistics_req_args() throw() {}
+
+ TableStatsRequest request;
+
+ _ThriftHiveMetastore_get_table_statistics_req_args__isset __isset;
+
+ void __set_request(const TableStatsRequest& val) {
+ request = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_table_statistics_req_args & rhs) const
+ {
+ if (!(request == rhs.request))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_table_statistics_req_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_statistics_req_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_table_statistics_req_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_statistics_req_pargs() throw() {}
+
+ const TableStatsRequest* request;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_statistics_req_result__isset {
+ _ThriftHiveMetastore_get_table_statistics_req_result__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_table_statistics_req_result__isset;
+
+class ThriftHiveMetastore_get_table_statistics_req_result {
+ public:
+
+ ThriftHiveMetastore_get_table_statistics_req_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_table_statistics_req_result() throw() {}
+
+ TableStatsResult success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_table_statistics_req_result__isset __isset;
+
+ void __set_success(const TableStatsResult& val) {
+ success = val;
+ }
+
+ void __set_o1(const NoSuchObjectException& val) {
+ o1 = val;
+ }
+
+ void __set_o2(const MetaException& val) {
+ o2 = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_table_statistics_req_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_table_statistics_req_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_table_statistics_req_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_table_statistics_req_presult__isset {
+ _ThriftHiveMetastore_get_table_statistics_req_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_table_statistics_req_presult__isset;
+
+class ThriftHiveMetastore_get_table_statistics_req_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_table_statistics_req_presult() throw() {}
+
+ TableStatsResult* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_table_statistics_req_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_args__isset {
+ _ThriftHiveMetastore_get_partitions_statistics_req_args__isset() : request(false) {}
+ bool request;
+} _ThriftHiveMetastore_get_partitions_statistics_req_args__isset;
+
+class ThriftHiveMetastore_get_partitions_statistics_req_args {
+ public:
+
+ ThriftHiveMetastore_get_partitions_statistics_req_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_partitions_statistics_req_args() throw() {}
+
+ PartitionsStatsRequest request;
+
+ _ThriftHiveMetastore_get_partitions_statistics_req_args__isset __isset;
+
+ void __set_request(const PartitionsStatsRequest& val) {
+ request = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_args & rhs) const
+ {
+ if (!(request == rhs.request))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_partitions_statistics_req_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_partitions_statistics_req_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_partitions_statistics_req_pargs() throw() {}
+
+ const PartitionsStatsRequest* request;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_result__isset {
+ _ThriftHiveMetastore_get_partitions_statistics_req_result__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_partitions_statistics_req_result__isset;
+
+class ThriftHiveMetastore_get_partitions_statistics_req_result {
+ public:
+
+ ThriftHiveMetastore_get_partitions_statistics_req_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_partitions_statistics_req_result() throw() {}
+
+ PartitionsStatsResult success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_partitions_statistics_req_result__isset __isset;
+
+ void __set_success(const PartitionsStatsResult& val) {
+ success = val;
+ }
+
+ void __set_o1(const NoSuchObjectException& val) {
+ o1 = val;
+ }
+
+ void __set_o2(const MetaException& val) {
+ o2 = val;
+ }
+
+ bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_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_partitions_statistics_req_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset {
+ _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success;
+ bool o1;
+ bool o2;
+} _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset;
+
+class ThriftHiveMetastore_get_partitions_statistics_req_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_partitions_statistics_req_presult() throw() {}
+
+ PartitionsStatsResult* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_partitions_statistics_req_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;
@@ -12587,6 +12851,12 @@ class ThriftHiveMetastoreClient : virtua
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);
void send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
void recv_get_partition_column_statistics(ColumnStatistics& _return);
+ void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request);
+ void send_get_table_statistics_req(const TableStatsRequest& request);
+ void recv_get_table_statistics_req(TableStatsResult& _return);
+ 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);
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();
@@ -12713,6 +12983,8 @@ class ThriftHiveMetastoreProcessor : pub
void process_update_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
void process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
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_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_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -12801,6 +13073,8 @@ class ThriftHiveMetastoreProcessor : pub
processMap_["update_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_partition_column_statistics;
processMap_["get_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_table_column_statistics;
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_["delete_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics;
processMap_["delete_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_table_column_statistics;
processMap_["create_role"] = &ThriftHiveMetastoreProcessor::process_create_role;
@@ -13503,6 +13777,26 @@ class ThriftHiveMetastoreMultiface : vir
return;
}
+ void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->get_table_statistics_req(_return, request);
+ }
+ ifaces_[i]->get_table_statistics_req(_return, request);
+ return;
+ }
+
+ void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) {
+ size_t sz = ifaces_.size();
+ size_t i = 0;
+ for (; i < (sz - 1); ++i) {
+ ifaces_[i]->get_partitions_statistics_req(_return, request);
+ }
+ ifaces_[i]->get_partitions_statistics_req(_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=1562653&r1=1562652&r2=1562653&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 Thu Jan 30 00:24:28 2014
@@ -362,6 +362,16 @@ class ThriftHiveMetastoreHandler : virtu
printf("get_partition_column_statistics\n");
}
+ void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) {
+ // Your implementation goes here
+ printf("get_table_statistics_req\n");
+ }
+
+ void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) {
+ // Your implementation goes here
+ printf("get_partitions_statistics_req\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=1562653&r1=1562652&r2=1562653&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 Thu Jan 30 00:24:28 2014
@@ -3944,10 +3944,10 @@ void swap(PartitionsByExprRequest &a, Pa
swap(a.__isset, b.__isset);
}
-const char* AddPartitionsResult::ascii_fingerprint = "5A689D0823E7BFBB60C799BA60065C31";
-const uint8_t AddPartitionsResult::binary_fingerprint[16] = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31};
+const char* TableStatsResult::ascii_fingerprint = "3A0CB62070A0D93EE2CE174AF08C0E92";
+const uint8_t TableStatsResult::binary_fingerprint[16] = {0x3A,0x0C,0xB6,0x20,0x70,0xA0,0xD9,0x3E,0xE2,0xCE,0x17,0x4A,0xF0,0x8C,0x0E,0x92};
-uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
uint32_t xfer = 0;
std::string fname;
@@ -3958,6 +3958,7 @@ uint32_t AddPartitionsResult::read(::apa
using ::apache::thrift::protocol::TProtocolException;
+ bool isset_tableStats = false;
while (true)
{
@@ -3970,15 +3971,474 @@ uint32_t AddPartitionsResult::read(::apa
case 1:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
- this->partitions.clear();
+ this->tableStats.clear();
uint32_t _size207;
::apache::thrift::protocol::TType _etype210;
xfer += iprot->readListBegin(_etype210, _size207);
- this->partitions.resize(_size207);
+ this->tableStats.resize(_size207);
uint32_t _i211;
for (_i211 = 0; _i211 < _size207; ++_i211)
{
- xfer += this->partitions[_i211].read(iprot);
+ xfer += this->tableStats[_i211].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_tableStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_tableStats)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TableStatsResult");
+
+ 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 _iter212;
+ for (_iter212 = this->tableStats.begin(); _iter212 != this->tableStats.end(); ++_iter212)
+ {
+ xfer += (*_iter212).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TableStatsResult &a, TableStatsResult &b) {
+ using ::std::swap;
+ swap(a.tableStats, b.tableStats);
+}
+
+const char* PartitionsStatsResult::ascii_fingerprint = "9790481369E1B27F6E70DED62CFCA4E3";
+const uint8_t PartitionsStatsResult::binary_fingerprint[16] = {0x97,0x90,0x48,0x13,0x69,0xE1,0xB2,0x7F,0x6E,0x70,0xDE,0xD6,0x2C,0xFC,0xA4,0xE3};
+
+uint32_t PartitionsStatsResult::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;
+
+ bool isset_partStats = 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_MAP) {
+ {
+ this->partStats.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)
+ {
+ std::string _key218;
+ xfer += iprot->readString(_key218);
+ std::vector<ColumnStatisticsObj> & _val219 = this->partStats[_key218];
+ {
+ _val219.clear();
+ uint32_t _size220;
+ ::apache::thrift::protocol::TType _etype223;
+ xfer += iprot->readListBegin(_etype223, _size220);
+ _val219.resize(_size220);
+ uint32_t _i224;
+ for (_i224 = 0; _i224 < _size220; ++_i224)
+ {
+ xfer += _val219[_i224].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ }
+ xfer += iprot->readMapEnd();
+ }
+ isset_partStats = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_partStats)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionsStatsResult");
+
+ 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 _iter225;
+ for (_iter225 = this->partStats.begin(); _iter225 != this->partStats.end(); ++_iter225)
+ {
+ xfer += oprot->writeString(_iter225->first);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter225->second.size()));
+ std::vector<ColumnStatisticsObj> ::const_iterator _iter226;
+ for (_iter226 = _iter225->second.begin(); _iter226 != _iter225->second.end(); ++_iter226)
+ {
+ xfer += (*_iter226).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) {
+ using ::std::swap;
+ swap(a.partStats, b.partStats);
+}
+
+const char* TableStatsRequest::ascii_fingerprint = "8E2AD6401E83558ECFD6A13D74DD0A3F";
+const uint8_t TableStatsRequest::binary_fingerprint[16] = {0x8E,0x2A,0xD6,0x40,0x1E,0x83,0x55,0x8E,0xCF,0xD6,0xA1,0x3D,0x74,0xDD,0x0A,0x3F};
+
+uint32_t TableStatsRequest::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;
+
+ bool isset_dbName = false;
+ bool isset_tblName = false;
+ bool isset_colNames = 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_STRING) {
+ xfer += iprot->readString(this->dbName);
+ isset_dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tblName);
+ isset_tblName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->colNames.clear();
+ uint32_t _size227;
+ ::apache::thrift::protocol::TType _etype230;
+ xfer += iprot->readListBegin(_etype230, _size227);
+ this->colNames.resize(_size227);
+ uint32_t _i231;
+ for (_i231 = 0; _i231 < _size227; ++_i231)
+ {
+ xfer += iprot->readString(this->colNames[_i231]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_colNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tblName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_colNames)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("TableStatsRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tblName);
+ xfer += oprot->writeFieldEnd();
+
+ 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 _iter232;
+ for (_iter232 = this->colNames.begin(); _iter232 != this->colNames.end(); ++_iter232)
+ {
+ xfer += oprot->writeString((*_iter232));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TableStatsRequest &a, TableStatsRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.colNames, b.colNames);
+}
+
+const char* PartitionsStatsRequest::ascii_fingerprint = "5F51D90BC323BCE4B704B7D98EDA0BD4";
+const uint8_t PartitionsStatsRequest::binary_fingerprint[16] = {0x5F,0x51,0xD9,0x0B,0xC3,0x23,0xBC,0xE4,0xB7,0x04,0xB7,0xD9,0x8E,0xDA,0x0B,0xD4};
+
+uint32_t PartitionsStatsRequest::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;
+
+ bool isset_dbName = false;
+ bool isset_tblName = false;
+ bool isset_colNames = false;
+ bool isset_partNames = 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_STRING) {
+ xfer += iprot->readString(this->dbName);
+ isset_dbName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tblName);
+ isset_tblName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->colNames.clear();
+ uint32_t _size233;
+ ::apache::thrift::protocol::TType _etype236;
+ xfer += iprot->readListBegin(_etype236, _size233);
+ this->colNames.resize(_size233);
+ uint32_t _i237;
+ for (_i237 = 0; _i237 < _size233; ++_i237)
+ {
+ xfer += iprot->readString(this->colNames[_i237]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_colNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->partNames.clear();
+ uint32_t _size238;
+ ::apache::thrift::protocol::TType _etype241;
+ xfer += iprot->readListBegin(_etype241, _size238);
+ this->partNames.resize(_size238);
+ uint32_t _i242;
+ for (_i242 = 0; _i242 < _size238; ++_i242)
+ {
+ xfer += iprot->readString(this->partNames[_i242]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_partNames = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_dbName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_tblName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_colNames)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_partNames)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("PartitionsStatsRequest");
+
+ xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tblName);
+ xfer += oprot->writeFieldEnd();
+
+ 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 _iter243;
+ for (_iter243 = this->colNames.begin(); _iter243 != this->colNames.end(); ++_iter243)
+ {
+ xfer += oprot->writeString((*_iter243));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ 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 _iter244;
+ for (_iter244 = this->partNames.begin(); _iter244 != this->partNames.end(); ++_iter244)
+ {
+ xfer += oprot->writeString((*_iter244));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) {
+ using ::std::swap;
+ swap(a.dbName, b.dbName);
+ swap(a.tblName, b.tblName);
+ swap(a.colNames, b.colNames);
+ swap(a.partNames, b.partNames);
+}
+
+const char* AddPartitionsResult::ascii_fingerprint = "5A689D0823E7BFBB60C799BA60065C31";
+const uint8_t AddPartitionsResult::binary_fingerprint[16] = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31};
+
+uint32_t AddPartitionsResult::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->partitions.clear();
+ uint32_t _size245;
+ ::apache::thrift::protocol::TType _etype248;
+ xfer += iprot->readListBegin(_etype248, _size245);
+ this->partitions.resize(_size245);
+ uint32_t _i249;
+ for (_i249 = 0; _i249 < _size245; ++_i249)
+ {
+ xfer += this->partitions[_i249].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4007,10 +4467,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 _iter212;
- for (_iter212 = this->partitions.begin(); _iter212 != this->partitions.end(); ++_iter212)
+ std::vector<Partition> ::const_iterator _iter250;
+ for (_iter250 = this->partitions.begin(); _iter250 != this->partitions.end(); ++_iter250)
{
- xfer += (*_iter212).write(oprot);
+ xfer += (*_iter250).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4074,14 +4534,14 @@ uint32_t AddPartitionsRequest::read(::ap
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->parts.clear();
- uint32_t _size213;
- ::apache::thrift::protocol::TType _etype216;
- xfer += iprot->readListBegin(_etype216, _size213);
- this->parts.resize(_size213);
- uint32_t _i217;
- for (_i217 = 0; _i217 < _size213; ++_i217)
+ uint32_t _size251;
+ ::apache::thrift::protocol::TType _etype254;
+ xfer += iprot->readListBegin(_etype254, _size251);
+ this->parts.resize(_size251);
+ uint32_t _i255;
+ for (_i255 = 0; _i255 < _size251; ++_i255)
{
- xfer += this->parts[_i217].read(iprot);
+ xfer += this->parts[_i255].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4141,10 +4601,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 _iter218;
- for (_iter218 = this->parts.begin(); _iter218 != this->parts.end(); ++_iter218)
+ std::vector<Partition> ::const_iterator _iter256;
+ for (_iter256 = this->parts.begin(); _iter256 != this->parts.end(); ++_iter256)
{
- xfer += (*_iter218).write(oprot);
+ xfer += (*_iter256).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=1562653&r1=1562652&r2=1562653&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 Thu Jan 30 00:24:28 2014
@@ -2094,6 +2094,189 @@ class PartitionsByExprRequest {
void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b);
+
+class TableStatsResult {
+ public:
+
+ static const char* ascii_fingerprint; // = "3A0CB62070A0D93EE2CE174AF08C0E92";
+ static const uint8_t binary_fingerprint[16]; // = {0x3A,0x0C,0xB6,0x20,0x70,0xA0,0xD9,0x3E,0xE2,0xCE,0x17,0x4A,0xF0,0x8C,0x0E,0x92};
+
+ TableStatsResult() {
+ }
+
+ virtual ~TableStatsResult() throw() {}
+
+ std::vector<ColumnStatisticsObj> tableStats;
+
+ void __set_tableStats(const std::vector<ColumnStatisticsObj> & val) {
+ tableStats = val;
+ }
+
+ bool operator == (const TableStatsResult & rhs) const
+ {
+ if (!(tableStats == rhs.tableStats))
+ return false;
+ return true;
+ }
+ bool operator != (const TableStatsResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TableStatsResult & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TableStatsResult &a, TableStatsResult &b);
+
+
+class PartitionsStatsResult {
+ public:
+
+ static const char* ascii_fingerprint; // = "9790481369E1B27F6E70DED62CFCA4E3";
+ static const uint8_t binary_fingerprint[16]; // = {0x97,0x90,0x48,0x13,0x69,0xE1,0xB2,0x7F,0x6E,0x70,0xDE,0xD6,0x2C,0xFC,0xA4,0xE3};
+
+ PartitionsStatsResult() {
+ }
+
+ virtual ~PartitionsStatsResult() throw() {}
+
+ std::map<std::string, std::vector<ColumnStatisticsObj> > partStats;
+
+ void __set_partStats(const std::map<std::string, std::vector<ColumnStatisticsObj> > & val) {
+ partStats = val;
+ }
+
+ bool operator == (const PartitionsStatsResult & rhs) const
+ {
+ if (!(partStats == rhs.partStats))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionsStatsResult &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionsStatsResult & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionsStatsResult &a, PartitionsStatsResult &b);
+
+
+class TableStatsRequest {
+ public:
+
+ static const char* ascii_fingerprint; // = "8E2AD6401E83558ECFD6A13D74DD0A3F";
+ static const uint8_t binary_fingerprint[16]; // = {0x8E,0x2A,0xD6,0x40,0x1E,0x83,0x55,0x8E,0xCF,0xD6,0xA1,0x3D,0x74,0xDD,0x0A,0x3F};
+
+ TableStatsRequest() : dbName(), tblName() {
+ }
+
+ virtual ~TableStatsRequest() throw() {}
+
+ std::string dbName;
+ std::string tblName;
+ std::vector<std::string> colNames;
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ }
+
+ void __set_tblName(const std::string& val) {
+ tblName = val;
+ }
+
+ void __set_colNames(const std::vector<std::string> & val) {
+ colNames = val;
+ }
+
+ bool operator == (const TableStatsRequest & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tblName == rhs.tblName))
+ return false;
+ if (!(colNames == rhs.colNames))
+ return false;
+ return true;
+ }
+ bool operator != (const TableStatsRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TableStatsRequest & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(TableStatsRequest &a, TableStatsRequest &b);
+
+
+class PartitionsStatsRequest {
+ public:
+
+ static const char* ascii_fingerprint; // = "5F51D90BC323BCE4B704B7D98EDA0BD4";
+ static const uint8_t binary_fingerprint[16]; // = {0x5F,0x51,0xD9,0x0B,0xC3,0x23,0xBC,0xE4,0xB7,0x04,0xB7,0xD9,0x8E,0xDA,0x0B,0xD4};
+
+ PartitionsStatsRequest() : dbName(), tblName() {
+ }
+
+ virtual ~PartitionsStatsRequest() throw() {}
+
+ std::string dbName;
+ std::string tblName;
+ std::vector<std::string> colNames;
+ std::vector<std::string> partNames;
+
+ void __set_dbName(const std::string& val) {
+ dbName = val;
+ }
+
+ void __set_tblName(const std::string& val) {
+ tblName = val;
+ }
+
+ void __set_colNames(const std::vector<std::string> & val) {
+ colNames = val;
+ }
+
+ void __set_partNames(const std::vector<std::string> & val) {
+ partNames = val;
+ }
+
+ bool operator == (const PartitionsStatsRequest & rhs) const
+ {
+ if (!(dbName == rhs.dbName))
+ return false;
+ if (!(tblName == rhs.tblName))
+ return false;
+ if (!(colNames == rhs.colNames))
+ return false;
+ if (!(partNames == rhs.partNames))
+ return false;
+ return true;
+ }
+ bool operator != (const PartitionsStatsRequest &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const PartitionsStatsRequest & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b);
+
typedef struct _AddPartitionsResult__isset {
_AddPartitionsResult__isset() : partitions(false) {}
bool partitions;
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=1562653&r1=1562652&r2=1562653&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 Thu Jan 30 00:24:28 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 _list272 = iprot.readListBegin();
- struct.parts = new ArrayList<Partition>(_list272.size);
- for (int _i273 = 0; _i273 < _list272.size; ++_i273)
+ org.apache.thrift.protocol.TList _list322 = iprot.readListBegin();
+ struct.parts = new ArrayList<Partition>(_list322.size);
+ for (int _i323 = 0; _i323 < _list322.size; ++_i323)
{
- Partition _elem274; // required
- _elem274 = new Partition();
- _elem274.read(iprot);
- struct.parts.add(_elem274);
+ Partition _elem324; // required
+ _elem324 = new Partition();
+ _elem324.read(iprot);
+ struct.parts.add(_elem324);
}
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 _iter275 : struct.parts)
+ for (Partition _iter325 : struct.parts)
{
- _iter275.write(oprot);
+ _iter325.write(oprot);
}
oprot.writeListEnd();
}
@@ -796,9 +796,9 @@ public class AddPartitionsRequest implem
oprot.writeString(struct.tblName);
{
oprot.writeI32(struct.parts.size());
- for (Partition _iter276 : struct.parts)
+ for (Partition _iter326 : struct.parts)
{
- _iter276.write(oprot);
+ _iter326.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 _list277 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
- struct.parts = new ArrayList<Partition>(_list277.size);
- for (int _i278 = 0; _i278 < _list277.size; ++_i278)
+ org.apache.thrift.protocol.TList _list327 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+ struct.parts = new ArrayList<Partition>(_list327.size);
+ for (int _i328 = 0; _i328 < _list327.size; ++_i328)
{
- Partition _elem279; // required
- _elem279 = new Partition();
- _elem279.read(iprot);
- struct.parts.add(_elem279);
+ Partition _elem329; // required
+ _elem329 = new Partition();
+ _elem329.read(iprot);
+ struct.parts.add(_elem329);
}
}
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=1562653&r1=1562652&r2=1562653&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 Thu Jan 30 00:24:28 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 _list264 = iprot.readListBegin();
- struct.partitions = new ArrayList<Partition>(_list264.size);
- for (int _i265 = 0; _i265 < _list264.size; ++_i265)
+ org.apache.thrift.protocol.TList _list314 = iprot.readListBegin();
+ struct.partitions = new ArrayList<Partition>(_list314.size);
+ for (int _i315 = 0; _i315 < _list314.size; ++_i315)
{
- Partition _elem266; // required
- _elem266 = new Partition();
- _elem266.read(iprot);
- struct.partitions.add(_elem266);
+ Partition _elem316; // required
+ _elem316 = new Partition();
+ _elem316.read(iprot);
+ struct.partitions.add(_elem316);
}
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 _iter267 : struct.partitions)
+ for (Partition _iter317 : struct.partitions)
{
- _iter267.write(oprot);
+ _iter317.write(oprot);
}
oprot.writeListEnd();
}
@@ -410,9 +410,9 @@ public class AddPartitionsResult impleme
if (struct.isSetPartitions()) {
{
oprot.writeI32(struct.partitions.size());
- for (Partition _iter268 : struct.partitions)
+ for (Partition _iter318 : struct.partitions)
{
- _iter268.write(oprot);
+ _iter318.write(oprot);
}
}
}
@@ -424,14 +424,14 @@ public class AddPartitionsResult impleme
BitSet incoming = iprot.readBitSet(1);
if (incoming.get(0)) {
{
- org.apache.thrift.protocol.TList _list269 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
- struct.partitions = new ArrayList<Partition>(_list269.size);
- for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+ org.apache.thrift.protocol.TList _list319 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+ struct.partitions = new ArrayList<Partition>(_list319.size);
+ for (int _i320 = 0; _i320 < _list319.size; ++_i320)
{
- Partition _elem271; // required
- _elem271 = new Partition();
- _elem271.read(iprot);
- struct.partitions.add(_elem271);
+ Partition _elem321; // required
+ _elem321 = new Partition();
+ _elem321.read(iprot);
+ struct.partitions.add(_elem321);
}
}
struct.setPartitionsIsSet(true);
Added: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsStatsRequest.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsStatsRequest.java?rev=1562653&view=auto
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsStatsRequest.java (added)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsStatsRequest.java Thu Jan 30 00:24:28 2014
@@ -0,0 +1,792 @@
+/**
+ * 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 PartitionsStatsRequest implements org.apache.thrift.TBase<PartitionsStatsRequest, PartitionsStatsRequest._Fields>, java.io.Serializable, Cloneable {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionsStatsRequest");
+
+ private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbName", org.apache.thrift.protocol.TType.STRING, (short)1);
+ private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tblName", org.apache.thrift.protocol.TType.STRING, (short)2);
+ private static final org.apache.thrift.protocol.TField COL_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("colNames", org.apache.thrift.protocol.TType.LIST, (short)3);
+ private static final org.apache.thrift.protocol.TField PART_NAMES_FIELD_DESC = new org.apache.thrift.protocol.TField("partNames", org.apache.thrift.protocol.TType.LIST, (short)4);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new PartitionsStatsRequestStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new PartitionsStatsRequestTupleSchemeFactory());
+ }
+
+ private String dbName; // required
+ private String tblName; // required
+ private List<String> colNames; // required
+ private List<String> partNames; // 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 {
+ DB_NAME((short)1, "dbName"),
+ TBL_NAME((short)2, "tblName"),
+ COL_NAMES((short)3, "colNames"),
+ PART_NAMES((short)4, "partNames");
+
+ 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: // DB_NAME
+ return DB_NAME;
+ case 2: // TBL_NAME
+ return TBL_NAME;
+ case 3: // COL_NAMES
+ return COL_NAMES;
+ case 4: // PART_NAMES
+ return PART_NAMES;
+ 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
+ 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.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("dbName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tblName", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ tmpMap.put(_Fields.COL_NAMES, new org.apache.thrift.meta_data.FieldMetaData("colNames", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ tmpMap.put(_Fields.PART_NAMES, new org.apache.thrift.meta_data.FieldMetaData("partNames", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PartitionsStatsRequest.class, metaDataMap);
+ }
+
+ public PartitionsStatsRequest() {
+ }
+
+ public PartitionsStatsRequest(
+ String dbName,
+ String tblName,
+ List<String> colNames,
+ List<String> partNames)
+ {
+ this();
+ this.dbName = dbName;
+ this.tblName = tblName;
+ this.colNames = colNames;
+ this.partNames = partNames;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public PartitionsStatsRequest(PartitionsStatsRequest other) {
+ if (other.isSetDbName()) {
+ this.dbName = other.dbName;
+ }
+ if (other.isSetTblName()) {
+ this.tblName = other.tblName;
+ }
+ if (other.isSetColNames()) {
+ List<String> __this__colNames = new ArrayList<String>();
+ for (String other_element : other.colNames) {
+ __this__colNames.add(other_element);
+ }
+ this.colNames = __this__colNames;
+ }
+ if (other.isSetPartNames()) {
+ List<String> __this__partNames = new ArrayList<String>();
+ for (String other_element : other.partNames) {
+ __this__partNames.add(other_element);
+ }
+ this.partNames = __this__partNames;
+ }
+ }
+
+ public PartitionsStatsRequest deepCopy() {
+ return new PartitionsStatsRequest(this);
+ }
+
+ @Override
+ public void clear() {
+ this.dbName = null;
+ this.tblName = null;
+ this.colNames = null;
+ this.partNames = null;
+ }
+
+ public String getDbName() {
+ return this.dbName;
+ }
+
+ public void setDbName(String dbName) {
+ this.dbName = dbName;
+ }
+
+ public void unsetDbName() {
+ this.dbName = null;
+ }
+
+ /** Returns true if field dbName is set (has been assigned a value) and false otherwise */
+ public boolean isSetDbName() {
+ return this.dbName != null;
+ }
+
+ public void setDbNameIsSet(boolean value) {
+ if (!value) {
+ this.dbName = null;
+ }
+ }
+
+ public String getTblName() {
+ return this.tblName;
+ }
+
+ public void setTblName(String tblName) {
+ this.tblName = tblName;
+ }
+
+ public void unsetTblName() {
+ this.tblName = null;
+ }
+
+ /** Returns true if field tblName is set (has been assigned a value) and false otherwise */
+ public boolean isSetTblName() {
+ return this.tblName != null;
+ }
+
+ public void setTblNameIsSet(boolean value) {
+ if (!value) {
+ this.tblName = null;
+ }
+ }
+
+ public int getColNamesSize() {
+ return (this.colNames == null) ? 0 : this.colNames.size();
+ }
+
+ public java.util.Iterator<String> getColNamesIterator() {
+ return (this.colNames == null) ? null : this.colNames.iterator();
+ }
+
+ public void addToColNames(String elem) {
+ if (this.colNames == null) {
+ this.colNames = new ArrayList<String>();
+ }
+ this.colNames.add(elem);
+ }
+
+ public List<String> getColNames() {
+ return this.colNames;
+ }
+
+ public void setColNames(List<String> colNames) {
+ this.colNames = colNames;
+ }
+
+ public void unsetColNames() {
+ this.colNames = null;
+ }
+
+ /** Returns true if field colNames is set (has been assigned a value) and false otherwise */
+ public boolean isSetColNames() {
+ return this.colNames != null;
+ }
+
+ public void setColNamesIsSet(boolean value) {
+ if (!value) {
+ this.colNames = null;
+ }
+ }
+
+ public int getPartNamesSize() {
+ return (this.partNames == null) ? 0 : this.partNames.size();
+ }
+
+ public java.util.Iterator<String> getPartNamesIterator() {
+ return (this.partNames == null) ? null : this.partNames.iterator();
+ }
+
+ public void addToPartNames(String elem) {
+ if (this.partNames == null) {
+ this.partNames = new ArrayList<String>();
+ }
+ this.partNames.add(elem);
+ }
+
+ public List<String> getPartNames() {
+ return this.partNames;
+ }
+
+ public void setPartNames(List<String> partNames) {
+ this.partNames = partNames;
+ }
+
+ public void unsetPartNames() {
+ this.partNames = null;
+ }
+
+ /** Returns true if field partNames is set (has been assigned a value) and false otherwise */
+ public boolean isSetPartNames() {
+ return this.partNames != null;
+ }
+
+ public void setPartNamesIsSet(boolean value) {
+ if (!value) {
+ this.partNames = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case DB_NAME:
+ if (value == null) {
+ unsetDbName();
+ } else {
+ setDbName((String)value);
+ }
+ break;
+
+ case TBL_NAME:
+ if (value == null) {
+ unsetTblName();
+ } else {
+ setTblName((String)value);
+ }
+ break;
+
+ case COL_NAMES:
+ if (value == null) {
+ unsetColNames();
+ } else {
+ setColNames((List<String>)value);
+ }
+ break;
+
+ case PART_NAMES:
+ if (value == null) {
+ unsetPartNames();
+ } else {
+ setPartNames((List<String>)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case DB_NAME:
+ return getDbName();
+
+ case TBL_NAME:
+ return getTblName();
+
+ case COL_NAMES:
+ return getColNames();
+
+ case PART_NAMES:
+ return getPartNames();
+
+ }
+ 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 DB_NAME:
+ return isSetDbName();
+ case TBL_NAME:
+ return isSetTblName();
+ case COL_NAMES:
+ return isSetColNames();
+ case PART_NAMES:
+ return isSetPartNames();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof PartitionsStatsRequest)
+ return this.equals((PartitionsStatsRequest)that);
+ return false;
+ }
+
+ public boolean equals(PartitionsStatsRequest that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_dbName = true && this.isSetDbName();
+ boolean that_present_dbName = true && that.isSetDbName();
+ if (this_present_dbName || that_present_dbName) {
+ if (!(this_present_dbName && that_present_dbName))
+ return false;
+ if (!this.dbName.equals(that.dbName))
+ return false;
+ }
+
+ boolean this_present_tblName = true && this.isSetTblName();
+ boolean that_present_tblName = true && that.isSetTblName();
+ if (this_present_tblName || that_present_tblName) {
+ if (!(this_present_tblName && that_present_tblName))
+ return false;
+ if (!this.tblName.equals(that.tblName))
+ return false;
+ }
+
+ boolean this_present_colNames = true && this.isSetColNames();
+ boolean that_present_colNames = true && that.isSetColNames();
+ if (this_present_colNames || that_present_colNames) {
+ if (!(this_present_colNames && that_present_colNames))
+ return false;
+ if (!this.colNames.equals(that.colNames))
+ return false;
+ }
+
+ boolean this_present_partNames = true && this.isSetPartNames();
+ boolean that_present_partNames = true && that.isSetPartNames();
+ if (this_present_partNames || that_present_partNames) {
+ if (!(this_present_partNames && that_present_partNames))
+ return false;
+ if (!this.partNames.equals(that.partNames))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ HashCodeBuilder builder = new HashCodeBuilder();
+
+ boolean present_dbName = true && (isSetDbName());
+ builder.append(present_dbName);
+ if (present_dbName)
+ builder.append(dbName);
+
+ boolean present_tblName = true && (isSetTblName());
+ builder.append(present_tblName);
+ if (present_tblName)
+ builder.append(tblName);
+
+ boolean present_colNames = true && (isSetColNames());
+ builder.append(present_colNames);
+ if (present_colNames)
+ builder.append(colNames);
+
+ boolean present_partNames = true && (isSetPartNames());
+ builder.append(present_partNames);
+ if (present_partNames)
+ builder.append(partNames);
+
+ return builder.toHashCode();
+ }
+
+ public int compareTo(PartitionsStatsRequest other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ PartitionsStatsRequest typedOther = (PartitionsStatsRequest)other;
+
+ lastComparison = Boolean.valueOf(isSetDbName()).compareTo(typedOther.isSetDbName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetDbName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, typedOther.dbName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetTblName()).compareTo(typedOther.isSetTblName());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetTblName()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tblName, typedOther.tblName);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetColNames()).compareTo(typedOther.isSetColNames());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetColNames()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colNames, typedOther.colNames);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetPartNames()).compareTo(typedOther.isSetPartNames());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetPartNames()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partNames, typedOther.partNames);
+ 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("PartitionsStatsRequest(");
+ boolean first = true;
+
+ sb.append("dbName:");
+ if (this.dbName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.dbName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("tblName:");
+ if (this.tblName == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.tblName);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("colNames:");
+ if (this.colNames == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.colNames);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("partNames:");
+ if (this.partNames == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.partNames);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetDbName()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'dbName' is unset! Struct:" + toString());
+ }
+
+ if (!isSetTblName()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'tblName' is unset! Struct:" + toString());
+ }
+
+ if (!isSetColNames()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'colNames' is unset! Struct:" + toString());
+ }
+
+ if (!isSetPartNames()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'partNames' 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 {
+ 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 PartitionsStatsRequestStandardSchemeFactory implements SchemeFactory {
+ public PartitionsStatsRequestStandardScheme getScheme() {
+ return new PartitionsStatsRequestStandardScheme();
+ }
+ }
+
+ private static class PartitionsStatsRequestStandardScheme extends StandardScheme<PartitionsStatsRequest> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, PartitionsStatsRequest 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: // DB_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.dbName = iprot.readString();
+ struct.setDbNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 2: // TBL_NAME
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.tblName = iprot.readString();
+ struct.setTblNameIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 3: // COL_NAMES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list298 = iprot.readListBegin();
+ struct.colNames = new ArrayList<String>(_list298.size);
+ for (int _i299 = 0; _i299 < _list298.size; ++_i299)
+ {
+ String _elem300; // required
+ _elem300 = iprot.readString();
+ struct.colNames.add(_elem300);
+ }
+ iprot.readListEnd();
+ }
+ struct.setColNamesIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ case 4: // PART_NAMES
+ if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+ {
+ org.apache.thrift.protocol.TList _list301 = iprot.readListBegin();
+ struct.partNames = new ArrayList<String>(_list301.size);
+ for (int _i302 = 0; _i302 < _list301.size; ++_i302)
+ {
+ String _elem303; // required
+ _elem303 = iprot.readString();
+ struct.partNames.add(_elem303);
+ }
+ iprot.readListEnd();
+ }
+ struct.setPartNamesIsSet(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, PartitionsStatsRequest struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.dbName != null) {
+ oprot.writeFieldBegin(DB_NAME_FIELD_DESC);
+ oprot.writeString(struct.dbName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.tblName != null) {
+ oprot.writeFieldBegin(TBL_NAME_FIELD_DESC);
+ oprot.writeString(struct.tblName);
+ oprot.writeFieldEnd();
+ }
+ if (struct.colNames != null) {
+ oprot.writeFieldBegin(COL_NAMES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.colNames.size()));
+ for (String _iter304 : struct.colNames)
+ {
+ oprot.writeString(_iter304);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (struct.partNames != null) {
+ oprot.writeFieldBegin(PART_NAMES_FIELD_DESC);
+ {
+ oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.partNames.size()));
+ for (String _iter305 : struct.partNames)
+ {
+ oprot.writeString(_iter305);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class PartitionsStatsRequestTupleSchemeFactory implements SchemeFactory {
+ public PartitionsStatsRequestTupleScheme getScheme() {
+ return new PartitionsStatsRequestTupleScheme();
+ }
+ }
+
+ private static class PartitionsStatsRequestTupleScheme extends TupleScheme<PartitionsStatsRequest> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, PartitionsStatsRequest struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeString(struct.dbName);
+ oprot.writeString(struct.tblName);
+ {
+ oprot.writeI32(struct.colNames.size());
+ for (String _iter306 : struct.colNames)
+ {
+ oprot.writeString(_iter306);
+ }
+ }
+ {
+ oprot.writeI32(struct.partNames.size());
+ for (String _iter307 : struct.partNames)
+ {
+ oprot.writeString(_iter307);
+ }
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, PartitionsStatsRequest struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.dbName = iprot.readString();
+ struct.setDbNameIsSet(true);
+ struct.tblName = iprot.readString();
+ struct.setTblNameIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list308 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+ struct.colNames = new ArrayList<String>(_list308.size);
+ for (int _i309 = 0; _i309 < _list308.size; ++_i309)
+ {
+ String _elem310; // required
+ _elem310 = iprot.readString();
+ struct.colNames.add(_elem310);
+ }
+ }
+ struct.setColNamesIsSet(true);
+ {
+ org.apache.thrift.protocol.TList _list311 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
+ struct.partNames = new ArrayList<String>(_list311.size);
+ for (int _i312 = 0; _i312 < _list311.size; ++_i312)
+ {
+ String _elem313; // required
+ _elem313 = iprot.readString();
+ struct.partNames.add(_elem313);
+ }
+ }
+ struct.setPartNamesIsSet(true);
+ }
+ }
+
+}
+