[29/31] hive git commit: HIVE-14644 : use metastore information on the read path appropriately (Sergey Shelukhin)

[se...@apache.org]

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
index df555ec..573ec6b 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
@@ -174,6 +174,7 @@ class ThriftHiveMetastoreIf : virtual public  ::facebook::fb303::FacebookService
   virtual void get_next_write_id(GetNextWriteIdResult& _return, const GetNextWriteIdRequest& req) = 0;
   virtual void finalize_write_id(FinalizeWriteIdResult& _return, const FinalizeWriteIdRequest& req) = 0;
   virtual void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req) = 0;
+  virtual void get_valid_write_ids(GetValidWriteIdsResult& _return, const GetValidWriteIdsRequest& req) = 0;
 };
 
 class ThriftHiveMetastoreIfFactory : virtual public  ::facebook::fb303::FacebookServiceIfFactory {
@@ -687,6 +688,9 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p
   void heartbeat_write_id(HeartbeatWriteIdResult& /* _return */, const HeartbeatWriteIdRequest& /* req */) {
     return;
   }
+  void get_valid_write_ids(GetValidWriteIdsResult& /* _return */, const GetValidWriteIdsRequest& /* req */) {
+    return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -19455,6 +19459,110 @@ class ThriftHiveMetastore_heartbeat_write_id_presult {
 
 };
 
+typedef struct _ThriftHiveMetastore_get_valid_write_ids_args__isset {
+  _ThriftHiveMetastore_get_valid_write_ids_args__isset() : req(false) {}
+  bool req :1;
+} _ThriftHiveMetastore_get_valid_write_ids_args__isset;
+
+class ThriftHiveMetastore_get_valid_write_ids_args {
+ public:
+
+  ThriftHiveMetastore_get_valid_write_ids_args(const ThriftHiveMetastore_get_valid_write_ids_args&);
+  ThriftHiveMetastore_get_valid_write_ids_args& operator=(const ThriftHiveMetastore_get_valid_write_ids_args&);
+  ThriftHiveMetastore_get_valid_write_ids_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_valid_write_ids_args() throw();
+  GetValidWriteIdsRequest req;
+
+  _ThriftHiveMetastore_get_valid_write_ids_args__isset __isset;
+
+  void __set_req(const GetValidWriteIdsRequest& val);
+
+  bool operator == (const ThriftHiveMetastore_get_valid_write_ids_args & rhs) const
+  {
+    if (!(req == rhs.req))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_valid_write_ids_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_valid_write_ids_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_valid_write_ids_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_valid_write_ids_pargs() throw();
+  const GetValidWriteIdsRequest* req;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_valid_write_ids_result__isset {
+  _ThriftHiveMetastore_get_valid_write_ids_result__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_valid_write_ids_result__isset;
+
+class ThriftHiveMetastore_get_valid_write_ids_result {
+ public:
+
+  ThriftHiveMetastore_get_valid_write_ids_result(const ThriftHiveMetastore_get_valid_write_ids_result&);
+  ThriftHiveMetastore_get_valid_write_ids_result& operator=(const ThriftHiveMetastore_get_valid_write_ids_result&);
+  ThriftHiveMetastore_get_valid_write_ids_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_valid_write_ids_result() throw();
+  GetValidWriteIdsResult success;
+
+  _ThriftHiveMetastore_get_valid_write_ids_result__isset __isset;
+
+  void __set_success(const GetValidWriteIdsResult& val);
+
+  bool operator == (const ThriftHiveMetastore_get_valid_write_ids_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_valid_write_ids_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_valid_write_ids_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_valid_write_ids_presult__isset {
+  _ThriftHiveMetastore_get_valid_write_ids_presult__isset() : success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_valid_write_ids_presult__isset;
+
+class ThriftHiveMetastore_get_valid_write_ids_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_valid_write_ids_presult() throw();
+  GetValidWriteIdsResult* success;
+
+  _ThriftHiveMetastore_get_valid_write_ids_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceClient {
  public:
   ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
@@ -19922,6 +20030,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public
   void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req);
   void send_heartbeat_write_id(const HeartbeatWriteIdRequest& req);
   void recv_heartbeat_write_id(HeartbeatWriteIdResult& _return);
+  void get_valid_write_ids(GetValidWriteIdsResult& _return, const GetValidWriteIdsRequest& req);
+  void send_get_valid_write_ids(const GetValidWriteIdsRequest& req);
+  void recv_get_valid_write_ids(GetValidWriteIdsResult& _return);
 };
 
 class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceProcessor {
@@ -20084,6 +20195,7 @@ class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceP
   void process_get_next_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_finalize_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_heartbeat_write_id(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_valid_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  public:
   ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) :
      ::facebook::fb303::FacebookServiceProcessor(iface),
@@ -20240,6 +20352,7 @@ class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceP
     processMap_["get_next_write_id"] = &ThriftHiveMetastoreProcessor::process_get_next_write_id;
     processMap_["finalize_write_id"] = &ThriftHiveMetastoreProcessor::process_finalize_write_id;
     processMap_["heartbeat_write_id"] = &ThriftHiveMetastoreProcessor::process_heartbeat_write_id;
+    processMap_["get_valid_write_ids"] = &ThriftHiveMetastoreProcessor::process_get_valid_write_ids;
   }
 
   virtual ~ThriftHiveMetastoreProcessor() {}
@@ -21730,6 +21843,16 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi
     return;
   }
 
+  void get_valid_write_ids(GetValidWriteIdsResult& _return, const GetValidWriteIdsRequest& req) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_valid_write_ids(_return, req);
+    }
+    ifaces_[i]->get_valid_write_ids(_return, req);
+    return;
+  }
+
 };
 
 // The 'concurrent' client is a thread safe client that correctly handles
@@ -22202,6 +22325,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf
   void heartbeat_write_id(HeartbeatWriteIdResult& _return, const HeartbeatWriteIdRequest& req);
   int32_t send_heartbeat_write_id(const HeartbeatWriteIdRequest& req);
   void recv_heartbeat_write_id(HeartbeatWriteIdResult& _return, const int32_t seqid);
+  void get_valid_write_ids(GetValidWriteIdsResult& _return, const GetValidWriteIdsRequest& req);
+  int32_t send_get_valid_write_ids(const GetValidWriteIdsRequest& req);
+  void recv_get_valid_write_ids(GetValidWriteIdsResult& _return, const int32_t seqid);
 };
 
 #ifdef _WIN32

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
index 317598e..f938da4 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
@@ -782,6 +782,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf {
     printf("heartbeat_write_id\n");
   }
 
+  void get_valid_write_ids(GetValidWriteIdsResult& _return, const GetValidWriteIdsRequest& req) {
+    // Your implementation goes here
+    printf("get_valid_write_ids\n");
+  }
+
 };
 
 int main(int argc, char **argv) {

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index bdfa35b..356477e 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -18260,6 +18260,291 @@ void HeartbeatWriteIdResult::printTo(std::ostream& out) const {
 }
 
 
+GetValidWriteIdsRequest::~GetValidWriteIdsRequest() throw() {
+}
+
+
+void GetValidWriteIdsRequest::__set_dbName(const std::string& val) {
+  this->dbName = val;
+}
+
+void GetValidWriteIdsRequest::__set_tblName(const std::string& val) {
+  this->tblName = val;
+}
+
+uint32_t GetValidWriteIdsRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_dbName = false;
+  bool isset_tblName = 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;
+      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);
+  return xfer;
+}
+
+uint32_t GetValidWriteIdsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("GetValidWriteIdsRequest");
+
+  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->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b) {
+  using ::std::swap;
+  swap(a.dbName, b.dbName);
+  swap(a.tblName, b.tblName);
+}
+
+GetValidWriteIdsRequest::GetValidWriteIdsRequest(const GetValidWriteIdsRequest& other751) {
+  dbName = other751.dbName;
+  tblName = other751.tblName;
+}
+GetValidWriteIdsRequest& GetValidWriteIdsRequest::operator=(const GetValidWriteIdsRequest& other752) {
+  dbName = other752.dbName;
+  tblName = other752.tblName;
+  return *this;
+}
+void GetValidWriteIdsRequest::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "GetValidWriteIdsRequest(";
+  out << "dbName=" << to_string(dbName);
+  out << ", " << "tblName=" << to_string(tblName);
+  out << ")";
+}
+
+
+GetValidWriteIdsResult::~GetValidWriteIdsResult() throw() {
+}
+
+
+void GetValidWriteIdsResult::__set_lowWatermarkId(const int64_t val) {
+  this->lowWatermarkId = val;
+}
+
+void GetValidWriteIdsResult::__set_highWatermarkId(const int64_t val) {
+  this->highWatermarkId = val;
+}
+
+void GetValidWriteIdsResult::__set_areIdsValid(const bool val) {
+  this->areIdsValid = val;
+__isset.areIdsValid = true;
+}
+
+void GetValidWriteIdsResult::__set_ids(const std::vector<int64_t> & val) {
+  this->ids = val;
+__isset.ids = true;
+}
+
+uint32_t GetValidWriteIdsResult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_lowWatermarkId = false;
+  bool isset_highWatermarkId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->lowWatermarkId);
+          isset_lowWatermarkId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->highWatermarkId);
+          isset_highWatermarkId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->areIdsValid);
+          this->__isset.areIdsValid = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->ids.clear();
+            uint32_t _size753;
+            ::apache::thrift::protocol::TType _etype756;
+            xfer += iprot->readListBegin(_etype756, _size753);
+            this->ids.resize(_size753);
+            uint32_t _i757;
+            for (_i757 = 0; _i757 < _size753; ++_i757)
+            {
+              xfer += iprot->readI64(this->ids[_i757]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.ids = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_lowWatermarkId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_highWatermarkId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t GetValidWriteIdsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("GetValidWriteIdsResult");
+
+  xfer += oprot->writeFieldBegin("lowWatermarkId", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->lowWatermarkId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("highWatermarkId", ::apache::thrift::protocol::T_I64, 2);
+  xfer += oprot->writeI64(this->highWatermarkId);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.areIdsValid) {
+    xfer += oprot->writeFieldBegin("areIdsValid", ::apache::thrift::protocol::T_BOOL, 3);
+    xfer += oprot->writeBool(this->areIdsValid);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.ids) {
+    xfer += oprot->writeFieldBegin("ids", ::apache::thrift::protocol::T_LIST, 4);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->ids.size()));
+      std::vector<int64_t> ::const_iterator _iter758;
+      for (_iter758 = this->ids.begin(); _iter758 != this->ids.end(); ++_iter758)
+      {
+        xfer += oprot->writeI64((*_iter758));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GetValidWriteIdsResult &a, GetValidWriteIdsResult &b) {
+  using ::std::swap;
+  swap(a.lowWatermarkId, b.lowWatermarkId);
+  swap(a.highWatermarkId, b.highWatermarkId);
+  swap(a.areIdsValid, b.areIdsValid);
+  swap(a.ids, b.ids);
+  swap(a.__isset, b.__isset);
+}
+
+GetValidWriteIdsResult::GetValidWriteIdsResult(const GetValidWriteIdsResult& other759) {
+  lowWatermarkId = other759.lowWatermarkId;
+  highWatermarkId = other759.highWatermarkId;
+  areIdsValid = other759.areIdsValid;
+  ids = other759.ids;
+  __isset = other759.__isset;
+}
+GetValidWriteIdsResult& GetValidWriteIdsResult::operator=(const GetValidWriteIdsResult& other760) {
+  lowWatermarkId = other760.lowWatermarkId;
+  highWatermarkId = other760.highWatermarkId;
+  areIdsValid = other760.areIdsValid;
+  ids = other760.ids;
+  __isset = other760.__isset;
+  return *this;
+}
+void GetValidWriteIdsResult::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "GetValidWriteIdsResult(";
+  out << "lowWatermarkId=" << to_string(lowWatermarkId);
+  out << ", " << "highWatermarkId=" << to_string(highWatermarkId);
+  out << ", " << "areIdsValid="; (__isset.areIdsValid ? (out << to_string(areIdsValid)) : (out << "<null>"));
+  out << ", " << "ids="; (__isset.ids ? (out << to_string(ids)) : (out << "<null>"));
+  out << ")";
+}
+
+
 GetAllFunctionsResponse::~GetAllFunctionsResponse() throw() {
 }
 
@@ -18294,14 +18579,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->functions.clear();
-            uint32_t _size751;
-            ::apache::thrift::protocol::TType _etype754;
-            xfer += iprot->readListBegin(_etype754, _size751);
-            this->functions.resize(_size751);
-            uint32_t _i755;
-            for (_i755 = 0; _i755 < _size751; ++_i755)
+            uint32_t _size761;
+            ::apache::thrift::protocol::TType _etype764;
+            xfer += iprot->readListBegin(_etype764, _size761);
+            this->functions.resize(_size761);
+            uint32_t _i765;
+            for (_i765 = 0; _i765 < _size761; ++_i765)
             {
-              xfer += this->functions[_i755].read(iprot);
+              xfer += this->functions[_i765].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -18331,10 +18616,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o
     xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->functions.size()));
-      std::vector<Function> ::const_iterator _iter756;
-      for (_iter756 = this->functions.begin(); _iter756 != this->functions.end(); ++_iter756)
+      std::vector<Function> ::const_iterator _iter766;
+      for (_iter766 = this->functions.begin(); _iter766 != this->functions.end(); ++_iter766)
       {
-        xfer += (*_iter756).write(oprot);
+        xfer += (*_iter766).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -18351,13 +18636,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) {
   swap(a.__isset, b.__isset);
 }
 
-GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other757) {
-  functions = other757.functions;
-  __isset = other757.__isset;
+GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other767) {
+  functions = other767.functions;
+  __isset = other767.__isset;
 }
-GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other758) {
-  functions = other758.functions;
-  __isset = other758.__isset;
+GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other768) {
+  functions = other768.functions;
+  __isset = other768.__isset;
   return *this;
 }
 void GetAllFunctionsResponse::printTo(std::ostream& out) const {
@@ -18499,19 +18784,19 @@ void swap(TableMeta &a, TableMeta &b) {
   swap(a.__isset, b.__isset);
 }
 
-TableMeta::TableMeta(const TableMeta& other759) {
-  dbName = other759.dbName;
-  tableName = other759.tableName;
-  tableType = other759.tableType;
-  comments = other759.comments;
-  __isset = other759.__isset;
+TableMeta::TableMeta(const TableMeta& other769) {
+  dbName = other769.dbName;
+  tableName = other769.tableName;
+  tableType = other769.tableType;
+  comments = other769.comments;
+  __isset = other769.__isset;
 }
-TableMeta& TableMeta::operator=(const TableMeta& other760) {
-  dbName = other760.dbName;
-  tableName = other760.tableName;
-  tableType = other760.tableType;
-  comments = other760.comments;
-  __isset = other760.__isset;
+TableMeta& TableMeta::operator=(const TableMeta& other770) {
+  dbName = other770.dbName;
+  tableName = other770.tableName;
+  tableType = other770.tableType;
+  comments = other770.comments;
+  __isset = other770.__isset;
   return *this;
 }
 void TableMeta::printTo(std::ostream& out) const {
@@ -18594,13 +18879,13 @@ void swap(MetaException &a, MetaException &b) {
   swap(a.__isset, b.__isset);
 }
 
-MetaException::MetaException(const MetaException& other761) : TException() {
-  message = other761.message;
-  __isset = other761.__isset;
+MetaException::MetaException(const MetaException& other771) : TException() {
+  message = other771.message;
+  __isset = other771.__isset;
 }
-MetaException& MetaException::operator=(const MetaException& other762) {
-  message = other762.message;
-  __isset = other762.__isset;
+MetaException& MetaException::operator=(const MetaException& other772) {
+  message = other772.message;
+  __isset = other772.__isset;
   return *this;
 }
 void MetaException::printTo(std::ostream& out) const {
@@ -18691,13 +18976,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownTableException::UnknownTableException(const UnknownTableException& other763) : TException() {
-  message = other763.message;
-  __isset = other763.__isset;
+UnknownTableException::UnknownTableException(const UnknownTableException& other773) : TException() {
+  message = other773.message;
+  __isset = other773.__isset;
 }
-UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other764) {
-  message = other764.message;
-  __isset = other764.__isset;
+UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other774) {
+  message = other774.message;
+  __isset = other774.__isset;
   return *this;
 }
 void UnknownTableException::printTo(std::ostream& out) const {
@@ -18788,13 +19073,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownDBException::UnknownDBException(const UnknownDBException& other765) : TException() {
-  message = other765.message;
-  __isset = other765.__isset;
+UnknownDBException::UnknownDBException(const UnknownDBException& other775) : TException() {
+  message = other775.message;
+  __isset = other775.__isset;
 }
-UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other766) {
-  message = other766.message;
-  __isset = other766.__isset;
+UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other776) {
+  message = other776.message;
+  __isset = other776.__isset;
   return *this;
 }
 void UnknownDBException::printTo(std::ostream& out) const {
@@ -18885,13 +19170,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other767) : TException() {
-  message = other767.message;
-  __isset = other767.__isset;
+AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other777) : TException() {
+  message = other777.message;
+  __isset = other777.__isset;
 }
-AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other768) {
-  message = other768.message;
-  __isset = other768.__isset;
+AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other778) {
+  message = other778.message;
+  __isset = other778.__isset;
   return *this;
 }
 void AlreadyExistsException::printTo(std::ostream& out) const {
@@ -18982,13 +19267,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other769) : TException() {
-  message = other769.message;
-  __isset = other769.__isset;
+InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other779) : TException() {
+  message = other779.message;
+  __isset = other779.__isset;
 }
-InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other770) {
-  message = other770.message;
-  __isset = other770.__isset;
+InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other780) {
+  message = other780.message;
+  __isset = other780.__isset;
   return *this;
 }
 void InvalidPartitionException::printTo(std::ostream& out) const {
@@ -19079,13 +19364,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) {
   swap(a.__isset, b.__isset);
 }
 
-UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other771) : TException() {
-  message = other771.message;
-  __isset = other771.__isset;
+UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other781) : TException() {
+  message = other781.message;
+  __isset = other781.__isset;
 }
-UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other772) {
-  message = other772.message;
-  __isset = other772.__isset;
+UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other782) {
+  message = other782.message;
+  __isset = other782.__isset;
   return *this;
 }
 void UnknownPartitionException::printTo(std::ostream& out) const {
@@ -19176,13 +19461,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidObjectException::InvalidObjectException(const InvalidObjectException& other773) : TException() {
-  message = other773.message;
-  __isset = other773.__isset;
+InvalidObjectException::InvalidObjectException(const InvalidObjectException& other783) : TException() {
+  message = other783.message;
+  __isset = other783.__isset;
 }
-InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other774) {
-  message = other774.message;
-  __isset = other774.__isset;
+InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other784) {
+  message = other784.message;
+  __isset = other784.__isset;
   return *this;
 }
 void InvalidObjectException::printTo(std::ostream& out) const {
@@ -19273,13 +19558,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other775) : TException() {
-  message = other775.message;
-  __isset = other775.__isset;
+NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other785) : TException() {
+  message = other785.message;
+  __isset = other785.__isset;
 }
-NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other776) {
-  message = other776.message;
-  __isset = other776.__isset;
+NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other786) {
+  message = other786.message;
+  __isset = other786.__isset;
   return *this;
 }
 void NoSuchObjectException::printTo(std::ostream& out) const {
@@ -19370,13 +19655,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) {
   swap(a.__isset, b.__isset);
 }
 
-IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other777) : TException() {
-  message = other777.message;
-  __isset = other777.__isset;
+IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other787) : TException() {
+  message = other787.message;
+  __isset = other787.__isset;
 }
-IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other778) {
-  message = other778.message;
-  __isset = other778.__isset;
+IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other788) {
+  message = other788.message;
+  __isset = other788.__isset;
   return *this;
 }
 void IndexAlreadyExistsException::printTo(std::ostream& out) const {
@@ -19467,13 +19752,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidOperationException::InvalidOperationException(const InvalidOperationException& other779) : TException() {
-  message = other779.message;
-  __isset = other779.__isset;
+InvalidOperationException::InvalidOperationException(const InvalidOperationException& other789) : TException() {
+  message = other789.message;
+  __isset = other789.__isset;
 }
-InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other780) {
-  message = other780.message;
-  __isset = other780.__isset;
+InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other790) {
+  message = other790.message;
+  __isset = other790.__isset;
   return *this;
 }
 void InvalidOperationException::printTo(std::ostream& out) const {
@@ -19564,13 +19849,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) {
   swap(a.__isset, b.__isset);
 }
 
-ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other781) : TException() {
-  message = other781.message;
-  __isset = other781.__isset;
+ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other791) : TException() {
+  message = other791.message;
+  __isset = other791.__isset;
 }
-ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other782) {
-  message = other782.message;
-  __isset = other782.__isset;
+ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other792) {
+  message = other792.message;
+  __isset = other792.__isset;
   return *this;
 }
 void ConfigValSecurityException::printTo(std::ostream& out) const {
@@ -19661,13 +19946,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) {
   swap(a.__isset, b.__isset);
 }
 
-InvalidInputException::InvalidInputException(const InvalidInputException& other783) : TException() {
-  message = other783.message;
-  __isset = other783.__isset;
+InvalidInputException::InvalidInputException(const InvalidInputException& other793) : TException() {
+  message = other793.message;
+  __isset = other793.__isset;
 }
-InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other784) {
-  message = other784.message;
-  __isset = other784.__isset;
+InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other794) {
+  message = other794.message;
+  __isset = other794.__isset;
   return *this;
 }
 void InvalidInputException::printTo(std::ostream& out) const {
@@ -19758,13 +20043,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other785) : TException() {
-  message = other785.message;
-  __isset = other785.__isset;
+NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other795) : TException() {
+  message = other795.message;
+  __isset = other795.__isset;
 }
-NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other786) {
-  message = other786.message;
-  __isset = other786.__isset;
+NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other796) {
+  message = other796.message;
+  __isset = other796.__isset;
   return *this;
 }
 void NoSuchTxnException::printTo(std::ostream& out) const {
@@ -19855,13 +20140,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnAbortedException::TxnAbortedException(const TxnAbortedException& other787) : TException() {
-  message = other787.message;
-  __isset = other787.__isset;
+TxnAbortedException::TxnAbortedException(const TxnAbortedException& other797) : TException() {
+  message = other797.message;
+  __isset = other797.__isset;
 }
-TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other788) {
-  message = other788.message;
-  __isset = other788.__isset;
+TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other798) {
+  message = other798.message;
+  __isset = other798.__isset;
   return *this;
 }
 void TxnAbortedException::printTo(std::ostream& out) const {
@@ -19952,13 +20237,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) {
   swap(a.__isset, b.__isset);
 }
 
-TxnOpenException::TxnOpenException(const TxnOpenException& other789) : TException() {
-  message = other789.message;
-  __isset = other789.__isset;
+TxnOpenException::TxnOpenException(const TxnOpenException& other799) : TException() {
+  message = other799.message;
+  __isset = other799.__isset;
 }
-TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other790) {
-  message = other790.message;
-  __isset = other790.__isset;
+TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other800) {
+  message = other800.message;
+  __isset = other800.__isset;
   return *this;
 }
 void TxnOpenException::printTo(std::ostream& out) const {
@@ -20049,13 +20334,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) {
   swap(a.__isset, b.__isset);
 }
 
-NoSuchLockException::NoSuchLockException(const NoSuchLockException& other791) : TException() {
-  message = other791.message;
-  __isset = other791.__isset;
+NoSuchLockException::NoSuchLockException(const NoSuchLockException& other801) : TException() {
+  message = other801.message;
+  __isset = other801.__isset;
 }
-NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other792) {
-  message = other792.message;
-  __isset = other792.__isset;
+NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other802) {
+  message = other802.message;
+  __isset = other802.__isset;
   return *this;
 }
 void NoSuchLockException::printTo(std::ostream& out) const {

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index beddd4c..b510dc9 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -396,6 +396,10 @@ class HeartbeatWriteIdRequest;
 
 class HeartbeatWriteIdResult;
 
+class GetValidWriteIdsRequest;
+
+class GetValidWriteIdsResult;
+
 class GetAllFunctionsResponse;
 
 class TableMeta;
@@ -7445,6 +7449,117 @@ inline std::ostream& operator<<(std::ostream& out, const HeartbeatWriteIdResult&
   return out;
 }
 
+
+class GetValidWriteIdsRequest {
+ public:
+
+  GetValidWriteIdsRequest(const GetValidWriteIdsRequest&);
+  GetValidWriteIdsRequest& operator=(const GetValidWriteIdsRequest&);
+  GetValidWriteIdsRequest() : dbName(), tblName() {
+  }
+
+  virtual ~GetValidWriteIdsRequest() throw();
+  std::string dbName;
+  std::string tblName;
+
+  void __set_dbName(const std::string& val);
+
+  void __set_tblName(const std::string& val);
+
+  bool operator == (const GetValidWriteIdsRequest & rhs) const
+  {
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(tblName == rhs.tblName))
+      return false;
+    return true;
+  }
+  bool operator != (const GetValidWriteIdsRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const GetValidWriteIdsRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(GetValidWriteIdsRequest &a, GetValidWriteIdsRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _GetValidWriteIdsResult__isset {
+  _GetValidWriteIdsResult__isset() : areIdsValid(false), ids(false) {}
+  bool areIdsValid :1;
+  bool ids :1;
+} _GetValidWriteIdsResult__isset;
+
+class GetValidWriteIdsResult {
+ public:
+
+  GetValidWriteIdsResult(const GetValidWriteIdsResult&);
+  GetValidWriteIdsResult& operator=(const GetValidWriteIdsResult&);
+  GetValidWriteIdsResult() : lowWatermarkId(0), highWatermarkId(0), areIdsValid(0) {
+  }
+
+  virtual ~GetValidWriteIdsResult() throw();
+  int64_t lowWatermarkId;
+  int64_t highWatermarkId;
+  bool areIdsValid;
+  std::vector<int64_t>  ids;
+
+  _GetValidWriteIdsResult__isset __isset;
+
+  void __set_lowWatermarkId(const int64_t val);
+
+  void __set_highWatermarkId(const int64_t val);
+
+  void __set_areIdsValid(const bool val);
+
+  void __set_ids(const std::vector<int64_t> & val);
+
+  bool operator == (const GetValidWriteIdsResult & rhs) const
+  {
+    if (!(lowWatermarkId == rhs.lowWatermarkId))
+      return false;
+    if (!(highWatermarkId == rhs.highWatermarkId))
+      return false;
+    if (__isset.areIdsValid != rhs.__isset.areIdsValid)
+      return false;
+    else if (__isset.areIdsValid && !(areIdsValid == rhs.areIdsValid))
+      return false;
+    if (__isset.ids != rhs.__isset.ids)
+      return false;
+    else if (__isset.ids && !(ids == rhs.ids))
+      return false;
+    return true;
+  }
+  bool operator != (const GetValidWriteIdsResult &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const GetValidWriteIdsResult & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(GetValidWriteIdsResult &a, GetValidWriteIdsResult &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetValidWriteIdsResult& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _GetAllFunctionsResponse__isset {
   _GetAllFunctionsResponse__isset() : functions(false) {}
   bool functions :1;

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
index f427a3a..49a1be2 100644
--- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetAllFunctionsResponse.java
@@ -346,14 +346,14 @@ public class GetAllFunctionsResponse implements org.apache.thrift.TBase<GetAllFu
           case 1: // FUNCTIONS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list634 = iprot.readListBegin();
-                struct.functions = new ArrayList<Function>(_list634.size);
-                Function _elem635;
-                for (int _i636 = 0; _i636 < _list634.size; ++_i636)
+                org.apache.thrift.protocol.TList _list642 = iprot.readListBegin();
+                struct.functions = new ArrayList<Function>(_list642.size);
+                Function _elem643;
+                for (int _i644 = 0; _i644 < _list642.size; ++_i644)
                 {
-                  _elem635 = new Function();
-                  _elem635.read(iprot);
-                  struct.functions.add(_elem635);
+                  _elem643 = new Function();
+                  _elem643.read(iprot);
+                  struct.functions.add(_elem643);
                 }
                 iprot.readListEnd();
               }
@@ -380,9 +380,9 @@ public class GetAllFunctionsResponse implements org.apache.thrift.TBase<GetAllFu
           oprot.writeFieldBegin(FUNCTIONS_FIELD_DESC);
           {
             oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.functions.size()));
-            for (Function _iter637 : struct.functions)
+            for (Function _iter645 : struct.functions)
             {
-              _iter637.write(oprot);
+              _iter645.write(oprot);
             }
             oprot.writeListEnd();
           }
@@ -414,9 +414,9 @@ public class GetAllFunctionsResponse implements org.apache.thrift.TBase<GetAllFu
       if (struct.isSetFunctions()) {
         {
           oprot.writeI32(struct.functions.size());
-          for (Function _iter638 : struct.functions)
+          for (Function _iter646 : struct.functions)
           {
-            _iter638.write(oprot);
+            _iter646.write(oprot);
           }
         }
       }
@@ -428,14 +428,14 @@ public class GetAllFunctionsResponse implements org.apache.thrift.TBase<GetAllFu
       BitSet incoming = iprot.readBitSet(1);
       if (incoming.get(0)) {
         {
-          org.apache.thrift.protocol.TList _list639 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
-          struct.functions = new ArrayList<Function>(_list639.size);
-          Function _elem640;
-          for (int _i641 = 0; _i641 < _list639.size; ++_i641)
+          org.apache.thrift.protocol.TList _list647 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.functions = new ArrayList<Function>(_list647.size);
+          Function _elem648;
+          for (int _i649 = 0; _i649 < _list647.size; ++_i649)
           {
-            _elem640 = new Function();
-            _elem640.read(iprot);
-            struct.functions.add(_elem640);
+            _elem648 = new Function();
+            _elem648.read(iprot);
+            struct.functions.add(_elem648);
           }
         }
         struct.setFunctionsIsSet(true);

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java
new file mode 100644
index 0000000..90f103a
--- /dev/null
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsRequest.java
@@ -0,0 +1,490 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * 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.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 org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+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 javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class GetValidWriteIdsRequest implements org.apache.thrift.TBase<GetValidWriteIdsRequest, GetValidWriteIdsRequest._Fields>, java.io.Serializable, Cloneable, Comparable<GetValidWriteIdsRequest> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetValidWriteIdsRequest");
+
+  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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new GetValidWriteIdsRequestStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new GetValidWriteIdsRequestTupleSchemeFactory());
+  }
+
+  private String dbName; // required
+  private String tblName; // 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");
+
+    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;
+        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)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetValidWriteIdsRequest.class, metaDataMap);
+  }
+
+  public GetValidWriteIdsRequest() {
+  }
+
+  public GetValidWriteIdsRequest(
+    String dbName,
+    String tblName)
+  {
+    this();
+    this.dbName = dbName;
+    this.tblName = tblName;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public GetValidWriteIdsRequest(GetValidWriteIdsRequest other) {
+    if (other.isSetDbName()) {
+      this.dbName = other.dbName;
+    }
+    if (other.isSetTblName()) {
+      this.tblName = other.tblName;
+    }
+  }
+
+  public GetValidWriteIdsRequest deepCopy() {
+    return new GetValidWriteIdsRequest(this);
+  }
+
+  @Override
+  public void clear() {
+    this.dbName = null;
+    this.tblName = 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 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;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case DB_NAME:
+      return getDbName();
+
+    case TBL_NAME:
+      return getTblName();
+
+    }
+    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();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof GetValidWriteIdsRequest)
+      return this.equals((GetValidWriteIdsRequest)that);
+    return false;
+  }
+
+  public boolean equals(GetValidWriteIdsRequest 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;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_dbName = true && (isSetDbName());
+    list.add(present_dbName);
+    if (present_dbName)
+      list.add(dbName);
+
+    boolean present_tblName = true && (isSetTblName());
+    list.add(present_tblName);
+    if (present_tblName)
+      list.add(tblName);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(GetValidWriteIdsRequest other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetDbName()).compareTo(other.isSetDbName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetDbName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, other.dbName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetTblName()).compareTo(other.isSetTblName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetTblName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tblName, other.tblName);
+      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("GetValidWriteIdsRequest(");
+    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;
+    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());
+    }
+
+    // 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 GetValidWriteIdsRequestStandardSchemeFactory implements SchemeFactory {
+    public GetValidWriteIdsRequestStandardScheme getScheme() {
+      return new GetValidWriteIdsRequestStandardScheme();
+    }
+  }
+
+  private static class GetValidWriteIdsRequestStandardScheme extends StandardScheme<GetValidWriteIdsRequest> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, GetValidWriteIdsRequest 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;
+          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, GetValidWriteIdsRequest 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();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class GetValidWriteIdsRequestTupleSchemeFactory implements SchemeFactory {
+    public GetValidWriteIdsRequestTupleScheme getScheme() {
+      return new GetValidWriteIdsRequestTupleScheme();
+    }
+  }
+
+  private static class GetValidWriteIdsRequestTupleScheme extends TupleScheme<GetValidWriteIdsRequest> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeString(struct.dbName);
+      oprot.writeString(struct.tblName);
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.dbName = iprot.readString();
+      struct.setDbNameIsSet(true);
+      struct.tblName = iprot.readString();
+      struct.setTblNameIsSet(true);
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/3e481b47/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResult.java
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResult.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResult.java
new file mode 100644
index 0000000..a51f321
--- /dev/null
+++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetValidWriteIdsResult.java
@@ -0,0 +1,740 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * 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.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 org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+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 javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class GetValidWriteIdsResult implements org.apache.thrift.TBase<GetValidWriteIdsResult, GetValidWriteIdsResult._Fields>, java.io.Serializable, Cloneable, Comparable<GetValidWriteIdsResult> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetValidWriteIdsResult");
+
+  private static final org.apache.thrift.protocol.TField LOW_WATERMARK_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lowWatermarkId", org.apache.thrift.protocol.TType.I64, (short)1);
+  private static final org.apache.thrift.protocol.TField HIGH_WATERMARK_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("highWatermarkId", org.apache.thrift.protocol.TType.I64, (short)2);
+  private static final org.apache.thrift.protocol.TField ARE_IDS_VALID_FIELD_DESC = new org.apache.thrift.protocol.TField("areIdsValid", org.apache.thrift.protocol.TType.BOOL, (short)3);
+  private static final org.apache.thrift.protocol.TField IDS_FIELD_DESC = new org.apache.thrift.protocol.TField("ids", 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 GetValidWriteIdsResultStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new GetValidWriteIdsResultTupleSchemeFactory());
+  }
+
+  private long lowWatermarkId; // required
+  private long highWatermarkId; // required
+  private boolean areIdsValid; // optional
+  private List<Long> ids; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    LOW_WATERMARK_ID((short)1, "lowWatermarkId"),
+    HIGH_WATERMARK_ID((short)2, "highWatermarkId"),
+    ARE_IDS_VALID((short)3, "areIdsValid"),
+    IDS((short)4, "ids");
+
+    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: // LOW_WATERMARK_ID
+          return LOW_WATERMARK_ID;
+        case 2: // HIGH_WATERMARK_ID
+          return HIGH_WATERMARK_ID;
+        case 3: // ARE_IDS_VALID
+          return ARE_IDS_VALID;
+        case 4: // IDS
+          return IDS;
+        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 __LOWWATERMARKID_ISSET_ID = 0;
+  private static final int __HIGHWATERMARKID_ISSET_ID = 1;
+  private static final int __AREIDSVALID_ISSET_ID = 2;
+  private byte __isset_bitfield = 0;
+  private static final _Fields optionals[] = {_Fields.ARE_IDS_VALID,_Fields.IDS};
+  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.LOW_WATERMARK_ID, new org.apache.thrift.meta_data.FieldMetaData("lowWatermarkId", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.HIGH_WATERMARK_ID, new org.apache.thrift.meta_data.FieldMetaData("highWatermarkId", org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.ARE_IDS_VALID, new org.apache.thrift.meta_data.FieldMetaData("areIdsValid", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+    tmpMap.put(_Fields.IDS, new org.apache.thrift.meta_data.FieldMetaData("ids", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        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.I64))));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetValidWriteIdsResult.class, metaDataMap);
+  }
+
+  public GetValidWriteIdsResult() {
+  }
+
+  public GetValidWriteIdsResult(
+    long lowWatermarkId,
+    long highWatermarkId)
+  {
+    this();
+    this.lowWatermarkId = lowWatermarkId;
+    setLowWatermarkIdIsSet(true);
+    this.highWatermarkId = highWatermarkId;
+    setHighWatermarkIdIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public GetValidWriteIdsResult(GetValidWriteIdsResult other) {
+    __isset_bitfield = other.__isset_bitfield;
+    this.lowWatermarkId = other.lowWatermarkId;
+    this.highWatermarkId = other.highWatermarkId;
+    this.areIdsValid = other.areIdsValid;
+    if (other.isSetIds()) {
+      List<Long> __this__ids = new ArrayList<Long>(other.ids);
+      this.ids = __this__ids;
+    }
+  }
+
+  public GetValidWriteIdsResult deepCopy() {
+    return new GetValidWriteIdsResult(this);
+  }
+
+  @Override
+  public void clear() {
+    setLowWatermarkIdIsSet(false);
+    this.lowWatermarkId = 0;
+    setHighWatermarkIdIsSet(false);
+    this.highWatermarkId = 0;
+    setAreIdsValidIsSet(false);
+    this.areIdsValid = false;
+    this.ids = null;
+  }
+
+  public long getLowWatermarkId() {
+    return this.lowWatermarkId;
+  }
+
+  public void setLowWatermarkId(long lowWatermarkId) {
+    this.lowWatermarkId = lowWatermarkId;
+    setLowWatermarkIdIsSet(true);
+  }
+
+  public void unsetLowWatermarkId() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LOWWATERMARKID_ISSET_ID);
+  }
+
+  /** Returns true if field lowWatermarkId is set (has been assigned a value) and false otherwise */
+  public boolean isSetLowWatermarkId() {
+    return EncodingUtils.testBit(__isset_bitfield, __LOWWATERMARKID_ISSET_ID);
+  }
+
+  public void setLowWatermarkIdIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LOWWATERMARKID_ISSET_ID, value);
+  }
+
+  public long getHighWatermarkId() {
+    return this.highWatermarkId;
+  }
+
+  public void setHighWatermarkId(long highWatermarkId) {
+    this.highWatermarkId = highWatermarkId;
+    setHighWatermarkIdIsSet(true);
+  }
+
+  public void unsetHighWatermarkId() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __HIGHWATERMARKID_ISSET_ID);
+  }
+
+  /** Returns true if field highWatermarkId is set (has been assigned a value) and false otherwise */
+  public boolean isSetHighWatermarkId() {
+    return EncodingUtils.testBit(__isset_bitfield, __HIGHWATERMARKID_ISSET_ID);
+  }
+
+  public void setHighWatermarkIdIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __HIGHWATERMARKID_ISSET_ID, value);
+  }
+
+  public boolean isAreIdsValid() {
+    return this.areIdsValid;
+  }
+
+  public void setAreIdsValid(boolean areIdsValid) {
+    this.areIdsValid = areIdsValid;
+    setAreIdsValidIsSet(true);
+  }
+
+  public void unsetAreIdsValid() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __AREIDSVALID_ISSET_ID);
+  }
+
+  /** Returns true if field areIdsValid is set (has been assigned a value) and false otherwise */
+  public boolean isSetAreIdsValid() {
+    return EncodingUtils.testBit(__isset_bitfield, __AREIDSVALID_ISSET_ID);
+  }
+
+  public void setAreIdsValidIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __AREIDSVALID_ISSET_ID, value);
+  }
+
+  public int getIdsSize() {
+    return (this.ids == null) ? 0 : this.ids.size();
+  }
+
+  public java.util.Iterator<Long> getIdsIterator() {
+    return (this.ids == null) ? null : this.ids.iterator();
+  }
+
+  public void addToIds(long elem) {
+    if (this.ids == null) {
+      this.ids = new ArrayList<Long>();
+    }
+    this.ids.add(elem);
+  }
+
+  public List<Long> getIds() {
+    return this.ids;
+  }
+
+  public void setIds(List<Long> ids) {
+    this.ids = ids;
+  }
+
+  public void unsetIds() {
+    this.ids = null;
+  }
+
+  /** Returns true if field ids is set (has been assigned a value) and false otherwise */
+  public boolean isSetIds() {
+    return this.ids != null;
+  }
+
+  public void setIdsIsSet(boolean value) {
+    if (!value) {
+      this.ids = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case LOW_WATERMARK_ID:
+      if (value == null) {
+        unsetLowWatermarkId();
+      } else {
+        setLowWatermarkId((Long)value);
+      }
+      break;
+
+    case HIGH_WATERMARK_ID:
+      if (value == null) {
+        unsetHighWatermarkId();
+      } else {
+        setHighWatermarkId((Long)value);
+      }
+      break;
+
+    case ARE_IDS_VALID:
+      if (value == null) {
+        unsetAreIdsValid();
+      } else {
+        setAreIdsValid((Boolean)value);
+      }
+      break;
+
+    case IDS:
+      if (value == null) {
+        unsetIds();
+      } else {
+        setIds((List<Long>)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case LOW_WATERMARK_ID:
+      return getLowWatermarkId();
+
+    case HIGH_WATERMARK_ID:
+      return getHighWatermarkId();
+
+    case ARE_IDS_VALID:
+      return isAreIdsValid();
+
+    case IDS:
+      return getIds();
+
+    }
+    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 LOW_WATERMARK_ID:
+      return isSetLowWatermarkId();
+    case HIGH_WATERMARK_ID:
+      return isSetHighWatermarkId();
+    case ARE_IDS_VALID:
+      return isSetAreIdsValid();
+    case IDS:
+      return isSetIds();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof GetValidWriteIdsResult)
+      return this.equals((GetValidWriteIdsResult)that);
+    return false;
+  }
+
+  public boolean equals(GetValidWriteIdsResult that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_lowWatermarkId = true;
+    boolean that_present_lowWatermarkId = true;
+    if (this_present_lowWatermarkId || that_present_lowWatermarkId) {
+      if (!(this_present_lowWatermarkId && that_present_lowWatermarkId))
+        return false;
+      if (this.lowWatermarkId != that.lowWatermarkId)
+        return false;
+    }
+
+    boolean this_present_highWatermarkId = true;
+    boolean that_present_highWatermarkId = true;
+    if (this_present_highWatermarkId || that_present_highWatermarkId) {
+      if (!(this_present_highWatermarkId && that_present_highWatermarkId))
+        return false;
+      if (this.highWatermarkId != that.highWatermarkId)
+        return false;
+    }
+
+    boolean this_present_areIdsValid = true && this.isSetAreIdsValid();
+    boolean that_present_areIdsValid = true && that.isSetAreIdsValid();
+    if (this_present_areIdsValid || that_present_areIdsValid) {
+      if (!(this_present_areIdsValid && that_present_areIdsValid))
+        return false;
+      if (this.areIdsValid != that.areIdsValid)
+        return false;
+    }
+
+    boolean this_present_ids = true && this.isSetIds();
+    boolean that_present_ids = true && that.isSetIds();
+    if (this_present_ids || that_present_ids) {
+      if (!(this_present_ids && that_present_ids))
+        return false;
+      if (!this.ids.equals(that.ids))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_lowWatermarkId = true;
+    list.add(present_lowWatermarkId);
+    if (present_lowWatermarkId)
+      list.add(lowWatermarkId);
+
+    boolean present_highWatermarkId = true;
+    list.add(present_highWatermarkId);
+    if (present_highWatermarkId)
+      list.add(highWatermarkId);
+
+    boolean present_areIdsValid = true && (isSetAreIdsValid());
+    list.add(present_areIdsValid);
+    if (present_areIdsValid)
+      list.add(areIdsValid);
+
+    boolean present_ids = true && (isSetIds());
+    list.add(present_ids);
+    if (present_ids)
+      list.add(ids);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(GetValidWriteIdsResult other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetLowWatermarkId()).compareTo(other.isSetLowWatermarkId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetLowWatermarkId()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lowWatermarkId, other.lowWatermarkId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetHighWatermarkId()).compareTo(other.isSetHighWatermarkId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetHighWatermarkId()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.highWatermarkId, other.highWatermarkId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetAreIdsValid()).compareTo(other.isSetAreIdsValid());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetAreIdsValid()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.areIdsValid, other.areIdsValid);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetIds()).compareTo(other.isSetIds());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetIds()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ids, other.ids);
+      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("GetValidWriteIdsResult(");
+    boolean first = true;
+
+    sb.append("lowWatermarkId:");
+    sb.append(this.lowWatermarkId);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("highWatermarkId:");
+    sb.append(this.highWatermarkId);
+    first = false;
+    if (isSetAreIdsValid()) {
+      if (!first) sb.append(", ");
+      sb.append("areIdsValid:");
+      sb.append(this.areIdsValid);
+      first = false;
+    }
+    if (isSetIds()) {
+      if (!first) sb.append(", ");
+      sb.append("ids:");
+      if (this.ids == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.ids);
+      }
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetLowWatermarkId()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'lowWatermarkId' is unset! Struct:" + toString());
+    }
+
+    if (!isSetHighWatermarkId()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 'highWatermarkId' 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 GetValidWriteIdsResultStandardSchemeFactory implements SchemeFactory {
+    public GetValidWriteIdsResultStandardScheme getScheme() {
+      return new GetValidWriteIdsResultStandardScheme();
+    }
+  }
+
+  private static class GetValidWriteIdsResultStandardScheme extends StandardScheme<GetValidWriteIdsResult> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, GetValidWriteIdsResult 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: // LOW_WATERMARK_ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.lowWatermarkId = iprot.readI64();
+              struct.setLowWatermarkIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // HIGH_WATERMARK_ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.highWatermarkId = iprot.readI64();
+              struct.setHighWatermarkIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // ARE_IDS_VALID
+            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
+              struct.areIdsValid = iprot.readBool();
+              struct.setAreIdsValidIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // IDS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list634 = iprot.readListBegin();
+                struct.ids = new ArrayList<Long>(_list634.size);
+                long _elem635;
+                for (int _i636 = 0; _i636 < _list634.size; ++_i636)
+                {
+                  _elem635 = iprot.readI64();
+                  struct.ids.add(_elem635);
+                }
+                iprot.readListEnd();
+              }
+              struct.setIdsIsSet(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, GetValidWriteIdsResult struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(LOW_WATERMARK_ID_FIELD_DESC);
+      oprot.writeI64(struct.lowWatermarkId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(HIGH_WATERMARK_ID_FIELD_DESC);
+      oprot.writeI64(struct.highWatermarkId);
+      oprot.writeFieldEnd();
+      if (struct.isSetAreIdsValid()) {
+        oprot.writeFieldBegin(ARE_IDS_VALID_FIELD_DESC);
+        oprot.writeBool(struct.areIdsValid);
+        oprot.writeFieldEnd();
+      }
+      if (struct.ids != null) {
+        if (struct.isSetIds()) {
+          oprot.writeFieldBegin(IDS_FIELD_DESC);
+          {
+            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.ids.size()));
+            for (long _iter637 : struct.ids)
+            {
+              oprot.writeI64(_iter637);
+            }
+            oprot.writeListEnd();
+          }
+          oprot.writeFieldEnd();
+        }
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class GetValidWriteIdsResultTupleSchemeFactory implements SchemeFactory {
+    public GetValidWriteIdsResultTupleScheme getScheme() {
+      return new GetValidWriteIdsResultTupleScheme();
+    }
+  }
+
+  private static class GetValidWriteIdsResultTupleScheme extends TupleScheme<GetValidWriteIdsResult> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsResult struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeI64(struct.lowWatermarkId);
+      oprot.writeI64(struct.highWatermarkId);
+      BitSet optionals = new BitSet();
+      if (struct.isSetAreIdsValid()) {
+        optionals.set(0);
+      }
+      if (struct.isSetIds()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetAreIdsValid()) {
+        oprot.writeBool(struct.areIdsValid);
+      }
+      if (struct.isSetIds()) {
+        {
+          oprot.writeI32(struct.ids.size());
+          for (long _iter638 : struct.ids)
+          {
+            oprot.writeI64(_iter638);
+          }
+        }
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, GetValidWriteIdsResult struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.lowWatermarkId = iprot.readI64();
+      struct.setLowWatermarkIdIsSet(true);
+      struct.highWatermarkId = iprot.readI64();
+      struct.setHighWatermarkIdIsSet(true);
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.areIdsValid = iprot.readBool();
+        struct.setAreIdsValidIsSet(true);
+      }
+      if (incoming.get(1)) {
+        {
+          org.apache.thrift.protocol.TList _list639 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32());
+          struct.ids = new ArrayList<Long>(_list639.size);
+          long _elem640;
+          for (int _i641 = 0; _i641 < _list639.size; ++_i641)
+          {
+            _elem640 = iprot.readI64();
+            struct.ids.add(_elem640);
+          }
+        }
+        struct.setIdsIsSet(true);
+      }
+    }
+  }
+
+}
+