hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hashut...@apache.org
Subject svn commit: r1615865 [3/10] - in /hive/trunk: metastore/if/ metastore/src/gen/thrift/gen-cpp/ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ metastore/src/gen/thrift/gen-php/metastore/ metastore/src/gen/thrift/gen-py/hive_m...
Date Tue, 05 Aug 2014 05:52:53 GMT
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);
+    }
+  }
+
+}
+



Mime
View raw message