http://git-wip-us.apache.org/repos/asf/hive/blob/be420098/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp 
b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
index c24055a..fd52f09 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
@@ -48766,6 +48766,444 @@ uint32_t 
ThriftHiveMetastore_get_serde_presult::read(::apache::thrift::protocol:
   return xfer;
 }
 
+
+ThriftHiveMetastore_get_lock_materialization_rebuild_args::~ThriftHiveMetastore_get_lock_materialization_rebuild_args()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_args::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;
+
+
+  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);
+          this->__isset.dbName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tableName);
+          this->__isset.tableName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->txnId);
+          this->__isset.txnId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_args::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_args");
+
+  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->dbName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tableName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->tableName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 
3);
+  xfer += oprot->writeI64(this->txnId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_get_lock_materialization_rebuild_pargs::~ThriftHiveMetastore_get_lock_materialization_rebuild_pargs()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_pargs::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_pargs");
+
+  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->dbName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tableName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->tableName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 
3);
+  xfer += oprot->writeI64((*(this->txnId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_get_lock_materialization_rebuild_result::~ThriftHiveMetastore_get_lock_materialization_rebuild_result()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_result::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_result::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_get_lock_materialization_rebuild_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", 
::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_get_lock_materialization_rebuild_presult::~ThriftHiveMetastore_get_lock_materialization_rebuild_presult()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_get_lock_materialization_rebuild_presult::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+
+ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::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;
+
+
+  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);
+          this->__isset.dbName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tableName);
+          this->__isset.tableName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->txnId);
+          this->__isset.txnId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args");
+
+  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->dbName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tableName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->tableName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 
3);
+  xfer += oprot->writeI64(this->txnId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs");
+
+  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->dbName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tableName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->tableName)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("txnId", ::apache::thrift::protocol::T_I64, 
3);
+  xfer += oprot->writeI64((*(this->txnId)));
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result::write(::apache::thrift::protocol::TProtocol*
 oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += 
oprot->writeStructBegin("ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", 
::apache::thrift::protocol::T_BOOL, 0);
+    xfer += oprot->writeBool(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult::~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult()
 throw() {
+}
+
+
+uint32_t 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult::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;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
 void ThriftHiveMetastoreClient::getMetaConf(std::string& _return, const 
std::string& key)
 {
   send_getMetaConf(key);
@@ -61432,6 +61870,126 @@ void 
ThriftHiveMetastoreClient::recv_get_serde(SerDeInfo& _return)
   throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_serde failed: unknown result");
 }
 
+void ThriftHiveMetastoreClient::get_lock_materialization_rebuild(LockResponse& 
_return, const std::string& dbName, const std::string& tableName, const int64_t 
txnId)
+{
+  send_get_lock_materialization_rebuild(dbName, tableName, txnId);
+  recv_get_lock_materialization_rebuild(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_lock_materialization_rebuild(const 
std::string& dbName, const std::string& tableName, const int64_t txnId)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_lock_materialization_rebuild", 
::apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_get_lock_materialization_rebuild_pargs args;
+  args.dbName = &dbName;
+  args.tableName = &tableName;
+  args.txnId = &txnId;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void 
ThriftHiveMetastoreClient::recv_get_lock_materialization_rebuild(LockResponse& 
_return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("get_lock_materialization_rebuild") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  ThriftHiveMetastore_get_lock_materialization_rebuild_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_lock_materialization_rebuild failed: unknown result");
+}
+
+bool ThriftHiveMetastoreClient::heartbeat_lock_materialization_rebuild(const 
std::string& dbName, const std::string& tableName, const int64_t txnId)
+{
+  send_heartbeat_lock_materialization_rebuild(dbName, tableName, txnId);
+  return recv_heartbeat_lock_materialization_rebuild();
+}
+
+void 
ThriftHiveMetastoreClient::send_heartbeat_lock_materialization_rebuild(const 
std::string& dbName, const std::string& tableName, const int64_t txnId)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("heartbeat_lock_materialization_rebuild", 
::apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs args;
+  args.dbName = &dbName;
+  args.tableName = &tableName;
+  args.txnId = &txnId;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+bool ThriftHiveMetastoreClient::recv_heartbeat_lock_materialization_rebuild()
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("heartbeat_lock_materialization_rebuild") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  bool _return;
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    return _return;
+  }
+  throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "heartbeat_lock_materialization_rebuild failed: unknown result");
+}
+
 bool 
ThriftHiveMetastoreProcessor::dispatchCall(::apache::thrift::protocol::TProtocol*
 iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, 
int32_t seqid, void* callContext) {
   ProcessMap::iterator pfn;
   pfn = processMap_.find(fname);
@@ -73350,6 +73908,114 @@ void 
ThriftHiveMetastoreProcessor::process_get_serde(int32_t seqid, ::apache::th
   }
 }
 
+void 
ThriftHiveMetastoreProcessor::process_get_lock_materialization_rebuild(int32_t 
seqid, ::apache::thrift::protocol::TProtocol* iprot, 
::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = 
this->eventHandler_->getContext("ThriftHiveMetastore.get_lock_materialization_rebuild",
 callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), 
ctx, "ThriftHiveMetastore.get_lock_materialization_rebuild");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, 
"ThriftHiveMetastore.get_lock_materialization_rebuild");
+  }
+
+  ThriftHiveMetastore_get_lock_materialization_rebuild_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, 
"ThriftHiveMetastore.get_lock_materialization_rebuild", bytes);
+  }
+
+  ThriftHiveMetastore_get_lock_materialization_rebuild_result result;
+  try {
+    iface_->get_lock_materialization_rebuild(result.success, args.dbName, 
args.tableName, args.txnId);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, 
"ThriftHiveMetastore.get_lock_materialization_rebuild");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_lock_materialization_rebuild", 
::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, 
"ThriftHiveMetastore.get_lock_materialization_rebuild");
+  }
+
+  oprot->writeMessageBegin("get_lock_materialization_rebuild", 
::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, 
"ThriftHiveMetastore.get_lock_materialization_rebuild", bytes);
+  }
+}
+
+void 
ThriftHiveMetastoreProcessor::process_heartbeat_lock_materialization_rebuild(int32_t
 seqid, ::apache::thrift::protocol::TProtocol* iprot, 
::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = NULL;
+  if (this->eventHandler_.get() != NULL) {
+    ctx = 
this->eventHandler_->getContext("ThriftHiveMetastore.heartbeat_lock_materialization_rebuild",
 callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), 
ctx, "ThriftHiveMetastore.heartbeat_lock_materialization_rebuild");
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preRead(ctx, 
"ThriftHiveMetastore.heartbeat_lock_materialization_rebuild");
+  }
+
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postRead(ctx, 
"ThriftHiveMetastore.heartbeat_lock_materialization_rebuild", bytes);
+  }
+
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result result;
+  try {
+    result.success = 
iface_->heartbeat_lock_materialization_rebuild(args.dbName, args.tableName, 
args.txnId);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != NULL) {
+      this->eventHandler_->handlerError(ctx, 
"ThriftHiveMetastore.heartbeat_lock_materialization_rebuild");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("heartbeat_lock_materialization_rebuild", 
::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->preWrite(ctx, 
"ThriftHiveMetastore.heartbeat_lock_materialization_rebuild");
+  }
+
+  oprot->writeMessageBegin("heartbeat_lock_materialization_rebuild", 
::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != NULL) {
+    this->eventHandler_->postWrite(ctx, 
"ThriftHiveMetastore.heartbeat_lock_materialization_rebuild", bytes);
+  }
+}
+
 ::boost::shared_ptr< ::apache::thrift::TProcessor > 
ThriftHiveMetastoreProcessorFactory::getProcessor(const 
::apache::thrift::TConnectionInfo& connInfo) {
   ::apache::thrift::ReleaseHandler< ThriftHiveMetastoreIfFactory > 
cleanup(handlerFactory_);
   ::boost::shared_ptr< ThriftHiveMetastoreIf > 
handler(handlerFactory_->getHandler(connInfo), cleanup);
@@ -90808,7 +91474,283 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_version(SchemaVersion&
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("get_schema_version") != 0) {
+      if (fname.compare("get_schema_version") != 0) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+
+        // in a bad state, don't commit
+        using ::apache::thrift::protocol::TProtocolException;
+        throw TProtocolException(TProtocolException::INVALID_DATA);
+      }
+      ThriftHiveMetastore_get_schema_version_presult result;
+      result.success = &_return;
+      result.read(iprot_);
+      iprot_->readMessageEnd();
+      iprot_->getTransport()->readEnd();
+
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
+      if (result.__isset.o1) {
+        sentry.commit();
+        throw result.o1;
+      }
+      if (result.__isset.o2) {
+        sentry.commit();
+        throw result.o2;
+      }
+      // in a bad state, don't commit
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_version failed: unknown result");
+    }
+    // seqid != rseqid
+    this->sync_.updatePending(fname, mtype, rseqid);
+
+    // this will temporarily unlock the readMutex, and let other clients get 
work done
+    this->sync_.waitForWork(seqid);
+  } // end while(true)
+}
+
+void 
ThriftHiveMetastoreConcurrentClient::get_schema_latest_version(SchemaVersion& 
_return, const ISchemaName& schemaName)
+{
+  int32_t seqid = send_get_schema_latest_version(schemaName);
+  recv_get_schema_latest_version(_return, seqid);
+}
+
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_latest_version(const 
ISchemaName& schemaName)
+{
+  int32_t cseqid = this->sync_.generateSeqId();
+  ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
+  oprot_->writeMessageBegin("get_schema_latest_version", 
::apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_get_schema_latest_version_pargs args;
+  args.schemaName = &schemaName;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+  return cseqid;
+}
+
+void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaVersion&
 _return, const int32_t seqid)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  // the read mutex gets dropped and reacquired as part of waitForWork()
+  // The destructor of this sentry wakes up other clients
+  ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);
+
+  while(true) {
+    if(!this->sync_.getPending(fname, mtype, rseqid)) {
+      iprot_->readMessageBegin(fname, mtype, rseqid);
+    }
+    if(seqid == rseqid) {
+      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+        ::apache::thrift::TApplicationException x;
+        x.read(iprot_);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+        sentry.commit();
+        throw x;
+      }
+      if (mtype != ::apache::thrift::protocol::T_REPLY) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+      }
+      if (fname.compare("get_schema_latest_version") != 0) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+
+        // in a bad state, don't commit
+        using ::apache::thrift::protocol::TProtocolException;
+        throw TProtocolException(TProtocolException::INVALID_DATA);
+      }
+      ThriftHiveMetastore_get_schema_latest_version_presult result;
+      result.success = &_return;
+      result.read(iprot_);
+      iprot_->readMessageEnd();
+      iprot_->getTransport()->readEnd();
+
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
+      if (result.__isset.o1) {
+        sentry.commit();
+        throw result.o1;
+      }
+      if (result.__isset.o2) {
+        sentry.commit();
+        throw result.o2;
+      }
+      // in a bad state, don't commit
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_latest_version failed: unknown result");
+    }
+    // seqid != rseqid
+    this->sync_.updatePending(fname, mtype, rseqid);
+
+    // this will temporarily unlock the readMutex, and let other clients get 
work done
+    this->sync_.waitForWork(seqid);
+  } // end while(true)
+}
+
+void 
ThriftHiveMetastoreConcurrentClient::get_schema_all_versions(std::vector<SchemaVersion>
 & _return, const ISchemaName& schemaName)
+{
+  int32_t seqid = send_get_schema_all_versions(schemaName);
+  recv_get_schema_all_versions(_return, seqid);
+}
+
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_all_versions(const 
ISchemaName& schemaName)
+{
+  int32_t cseqid = this->sync_.generateSeqId();
+  ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
+  oprot_->writeMessageBegin("get_schema_all_versions", 
::apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_get_schema_all_versions_pargs args;
+  args.schemaName = &schemaName;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+  return cseqid;
+}
+
+void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vector<SchemaVersion>
 & _return, const int32_t seqid)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  // the read mutex gets dropped and reacquired as part of waitForWork()
+  // The destructor of this sentry wakes up other clients
+  ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);
+
+  while(true) {
+    if(!this->sync_.getPending(fname, mtype, rseqid)) {
+      iprot_->readMessageBegin(fname, mtype, rseqid);
+    }
+    if(seqid == rseqid) {
+      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+        ::apache::thrift::TApplicationException x;
+        x.read(iprot_);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+        sentry.commit();
+        throw x;
+      }
+      if (mtype != ::apache::thrift::protocol::T_REPLY) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+      }
+      if (fname.compare("get_schema_all_versions") != 0) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+
+        // in a bad state, don't commit
+        using ::apache::thrift::protocol::TProtocolException;
+        throw TProtocolException(TProtocolException::INVALID_DATA);
+      }
+      ThriftHiveMetastore_get_schema_all_versions_presult result;
+      result.success = &_return;
+      result.read(iprot_);
+      iprot_->readMessageEnd();
+      iprot_->getTransport()->readEnd();
+
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
+      if (result.__isset.o1) {
+        sentry.commit();
+        throw result.o1;
+      }
+      if (result.__isset.o2) {
+        sentry.commit();
+        throw result.o2;
+      }
+      // in a bad state, don't commit
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_all_versions failed: unknown result");
+    }
+    // seqid != rseqid
+    this->sync_.updatePending(fname, mtype, rseqid);
+
+    // this will temporarily unlock the readMutex, and let other clients get 
work done
+    this->sync_.waitForWork(seqid);
+  } // end while(true)
+}
+
+void ThriftHiveMetastoreConcurrentClient::drop_schema_version(const 
SchemaVersionDescriptor& schemaVersion)
+{
+  int32_t seqid = send_drop_schema_version(schemaVersion);
+  recv_drop_schema_version(seqid);
+}
+
+int32_t ThriftHiveMetastoreConcurrentClient::send_drop_schema_version(const 
SchemaVersionDescriptor& schemaVersion)
+{
+  int32_t cseqid = this->sync_.generateSeqId();
+  ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
+  oprot_->writeMessageBegin("drop_schema_version", 
::apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_drop_schema_version_pargs args;
+  args.schemaVersion = &schemaVersion;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+  return cseqid;
+}
+
+void ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const 
int32_t seqid)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  // the read mutex gets dropped and reacquired as part of waitForWork()
+  // The destructor of this sentry wakes up other clients
+  ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);
+
+  while(true) {
+    if(!this->sync_.getPending(fname, mtype, rseqid)) {
+      iprot_->readMessageBegin(fname, mtype, rseqid);
+    }
+    if(seqid == rseqid) {
+      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+        ::apache::thrift::TApplicationException x;
+        x.read(iprot_);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+        sentry.commit();
+        throw x;
+      }
+      if (mtype != ::apache::thrift::protocol::T_REPLY) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+      }
+      if (fname.compare("drop_schema_version") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -90817,17 +91759,11 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_version(SchemaVersion&
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_get_schema_version_presult result;
-      result.success = &_return;
+      ThriftHiveMetastore_drop_schema_version_presult result;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
 
-      if (result.__isset.success) {
-        // _return pointer has now been filled
-        sentry.commit();
-        return;
-      }
       if (result.__isset.o1) {
         sentry.commit();
         throw result.o1;
@@ -90836,8 +91772,8 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_version(SchemaVersion&
         sentry.commit();
         throw result.o2;
       }
-      // in a bad state, don't commit
-      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_version failed: unknown result");
+      sentry.commit();
+      return;
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -90847,20 +91783,20 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_version(SchemaVersion&
   } // end while(true)
 }
 
-void 
ThriftHiveMetastoreConcurrentClient::get_schema_latest_version(SchemaVersion& 
_return, const ISchemaName& schemaName)
+void 
ThriftHiveMetastoreConcurrentClient::get_schemas_by_cols(FindSchemasByColsResp& 
_return, const FindSchemasByColsRqst& rqst)
 {
-  int32_t seqid = send_get_schema_latest_version(schemaName);
-  recv_get_schema_latest_version(_return, seqid);
+  int32_t seqid = send_get_schemas_by_cols(rqst);
+  recv_get_schemas_by_cols(_return, seqid);
 }
 
-int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_latest_version(const 
ISchemaName& schemaName)
+int32_t ThriftHiveMetastoreConcurrentClient::send_get_schemas_by_cols(const 
FindSchemasByColsRqst& rqst)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("get_schema_latest_version", 
::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("get_schemas_by_cols", 
::apache::thrift::protocol::T_CALL, cseqid);
 
-  ThriftHiveMetastore_get_schema_latest_version_pargs args;
-  args.schemaName = &schemaName;
+  ThriftHiveMetastore_get_schemas_by_cols_pargs args;
+  args.rqst = &rqst;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -90871,7 +91807,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_latest_version(cons
   return cseqid;
 }
 
-void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaVersion&
 _return, const int32_t seqid)
+void 
ThriftHiveMetastoreConcurrentClient::recv_get_schemas_by_cols(FindSchemasByColsResp&
 _return, const int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -90900,7 +91836,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaV
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("get_schema_latest_version") != 0) {
+      if (fname.compare("get_schemas_by_cols") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -90909,7 +91845,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaV
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_get_schema_latest_version_presult result;
+      ThriftHiveMetastore_get_schemas_by_cols_presult result;
       result.success = &_return;
       result.read(iprot_);
       iprot_->readMessageEnd();
@@ -90924,12 +91860,8 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaV
         sentry.commit();
         throw result.o1;
       }
-      if (result.__isset.o2) {
-        sentry.commit();
-        throw result.o2;
-      }
       // in a bad state, don't commit
-      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_latest_version failed: unknown result");
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schemas_by_cols failed: unknown result");
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -90939,20 +91871,20 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_latest_version(SchemaV
   } // end while(true)
 }
 
-void 
ThriftHiveMetastoreConcurrentClient::get_schema_all_versions(std::vector<SchemaVersion>
 & _return, const ISchemaName& schemaName)
+void ThriftHiveMetastoreConcurrentClient::map_schema_version_to_serde(const 
MapSchemaVersionToSerdeRequest& rqst)
 {
-  int32_t seqid = send_get_schema_all_versions(schemaName);
-  recv_get_schema_all_versions(_return, seqid);
+  int32_t seqid = send_map_schema_version_to_serde(rqst);
+  recv_map_schema_version_to_serde(seqid);
 }
 
-int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_all_versions(const 
ISchemaName& schemaName)
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_map_schema_version_to_serde(const 
MapSchemaVersionToSerdeRequest& rqst)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("get_schema_all_versions", 
::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("map_schema_version_to_serde", 
::apache::thrift::protocol::T_CALL, cseqid);
 
-  ThriftHiveMetastore_get_schema_all_versions_pargs args;
-  args.schemaName = &schemaName;
+  ThriftHiveMetastore_map_schema_version_to_serde_pargs args;
+  args.rqst = &rqst;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -90963,7 +91895,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_schema_all_versions(const
   return cseqid;
 }
 
-void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vector<SchemaVersion>
 & _return, const int32_t seqid)
+void 
ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const 
int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -90992,7 +91924,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vect
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("get_schema_all_versions") != 0) {
+      if (fname.compare("map_schema_version_to_serde") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91001,17 +91933,11 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vect
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_get_schema_all_versions_presult result;
-      result.success = &_return;
+      ThriftHiveMetastore_map_schema_version_to_serde_presult result;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
 
-      if (result.__isset.success) {
-        // _return pointer has now been filled
-        sentry.commit();
-        return;
-      }
       if (result.__isset.o1) {
         sentry.commit();
         throw result.o1;
@@ -91020,8 +91946,8 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vect
         sentry.commit();
         throw result.o2;
       }
-      // in a bad state, don't commit
-      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schema_all_versions failed: unknown result");
+      sentry.commit();
+      return;
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -91031,20 +91957,20 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schema_all_versions(std::vect
   } // end while(true)
 }
 
-void ThriftHiveMetastoreConcurrentClient::drop_schema_version(const 
SchemaVersionDescriptor& schemaVersion)
+void ThriftHiveMetastoreConcurrentClient::set_schema_version_state(const 
SetSchemaVersionStateRequest& rqst)
 {
-  int32_t seqid = send_drop_schema_version(schemaVersion);
-  recv_drop_schema_version(seqid);
+  int32_t seqid = send_set_schema_version_state(rqst);
+  recv_set_schema_version_state(seqid);
 }
 
-int32_t ThriftHiveMetastoreConcurrentClient::send_drop_schema_version(const 
SchemaVersionDescriptor& schemaVersion)
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_set_schema_version_state(const 
SetSchemaVersionStateRequest& rqst)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("drop_schema_version", 
::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("set_schema_version_state", 
::apache::thrift::protocol::T_CALL, cseqid);
 
-  ThriftHiveMetastore_drop_schema_version_pargs args;
-  args.schemaVersion = &schemaVersion;
+  ThriftHiveMetastore_set_schema_version_state_pargs args;
+  args.rqst = &rqst;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -91055,7 +91981,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_drop_schema_version(const Sche
   return cseqid;
 }
 
-void ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const 
int32_t seqid)
+void ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const 
int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -91084,7 +92010,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const int32_t
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("drop_schema_version") != 0) {
+      if (fname.compare("set_schema_version_state") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91093,7 +92019,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const int32_t
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_drop_schema_version_presult result;
+      ThriftHiveMetastore_set_schema_version_state_presult result;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
@@ -91106,96 +92032,12 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_drop_schema_version(const int32_t
         sentry.commit();
         throw result.o2;
       }
-      sentry.commit();
-      return;
-    }
-    // seqid != rseqid
-    this->sync_.updatePending(fname, mtype, rseqid);
-
-    // this will temporarily unlock the readMutex, and let other clients get 
work done
-    this->sync_.waitForWork(seqid);
-  } // end while(true)
-}
-
-void 
ThriftHiveMetastoreConcurrentClient::get_schemas_by_cols(FindSchemasByColsResp& 
_return, const FindSchemasByColsRqst& rqst)
-{
-  int32_t seqid = send_get_schemas_by_cols(rqst);
-  recv_get_schemas_by_cols(_return, seqid);
-}
-
-int32_t ThriftHiveMetastoreConcurrentClient::send_get_schemas_by_cols(const 
FindSchemasByColsRqst& rqst)
-{
-  int32_t cseqid = this->sync_.generateSeqId();
-  ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("get_schemas_by_cols", 
::apache::thrift::protocol::T_CALL, cseqid);
-
-  ThriftHiveMetastore_get_schemas_by_cols_pargs args;
-  args.rqst = &rqst;
-  args.write(oprot_);
-
-  oprot_->writeMessageEnd();
-  oprot_->getTransport()->writeEnd();
-  oprot_->getTransport()->flush();
-
-  sentry.commit();
-  return cseqid;
-}
-
-void 
ThriftHiveMetastoreConcurrentClient::recv_get_schemas_by_cols(FindSchemasByColsResp&
 _return, const int32_t seqid)
-{
-
-  int32_t rseqid = 0;
-  std::string fname;
-  ::apache::thrift::protocol::TMessageType mtype;
-
-  // the read mutex gets dropped and reacquired as part of waitForWork()
-  // The destructor of this sentry wakes up other clients
-  ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);
-
-  while(true) {
-    if(!this->sync_.getPending(fname, mtype, rseqid)) {
-      iprot_->readMessageBegin(fname, mtype, rseqid);
-    }
-    if(seqid == rseqid) {
-      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
-        ::apache::thrift::TApplicationException x;
-        x.read(iprot_);
-        iprot_->readMessageEnd();
-        iprot_->getTransport()->readEnd();
-        sentry.commit();
-        throw x;
-      }
-      if (mtype != ::apache::thrift::protocol::T_REPLY) {
-        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
-        iprot_->readMessageEnd();
-        iprot_->getTransport()->readEnd();
-      }
-      if (fname.compare("get_schemas_by_cols") != 0) {
-        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
-        iprot_->readMessageEnd();
-        iprot_->getTransport()->readEnd();
-
-        // in a bad state, don't commit
-        using ::apache::thrift::protocol::TProtocolException;
-        throw TProtocolException(TProtocolException::INVALID_DATA);
-      }
-      ThriftHiveMetastore_get_schemas_by_cols_presult result;
-      result.success = &_return;
-      result.read(iprot_);
-      iprot_->readMessageEnd();
-      iprot_->getTransport()->readEnd();
-
-      if (result.__isset.success) {
-        // _return pointer has now been filled
-        sentry.commit();
-        return;
-      }
-      if (result.__isset.o1) {
+      if (result.__isset.o3) {
         sentry.commit();
-        throw result.o1;
+        throw result.o3;
       }
-      // in a bad state, don't commit
-      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_schemas_by_cols failed: unknown result");
+      sentry.commit();
+      return;
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -91205,20 +92047,20 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_schemas_by_cols(FindSchemasBy
   } // end while(true)
 }
 
-void ThriftHiveMetastoreConcurrentClient::map_schema_version_to_serde(const 
MapSchemaVersionToSerdeRequest& rqst)
+void ThriftHiveMetastoreConcurrentClient::add_serde(const SerDeInfo& serde)
 {
-  int32_t seqid = send_map_schema_version_to_serde(rqst);
-  recv_map_schema_version_to_serde(seqid);
+  int32_t seqid = send_add_serde(serde);
+  recv_add_serde(seqid);
 }
 
-int32_t 
ThriftHiveMetastoreConcurrentClient::send_map_schema_version_to_serde(const 
MapSchemaVersionToSerdeRequest& rqst)
+int32_t ThriftHiveMetastoreConcurrentClient::send_add_serde(const SerDeInfo& 
serde)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("map_schema_version_to_serde", 
::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_CALL, 
cseqid);
 
-  ThriftHiveMetastore_map_schema_version_to_serde_pargs args;
-  args.rqst = &rqst;
+  ThriftHiveMetastore_add_serde_pargs args;
+  args.serde = &serde;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -91229,7 +92071,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_map_schema_version_to_serde(co
   return cseqid;
 }
 
-void 
ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const 
int32_t seqid)
+void ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -91258,7 +92100,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("map_schema_version_to_serde") != 0) {
+      if (fname.compare("add_serde") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91267,7 +92109,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_map_schema_version_to_serde_presult result;
+      ThriftHiveMetastore_add_serde_presult result;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
@@ -91291,19 +92133,19 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_map_schema_version_to_serde(const
   } // end while(true)
 }
 
-void ThriftHiveMetastoreConcurrentClient::set_schema_version_state(const 
SetSchemaVersionStateRequest& rqst)
+void ThriftHiveMetastoreConcurrentClient::get_serde(SerDeInfo& _return, const 
GetSerdeRequest& rqst)
 {
-  int32_t seqid = send_set_schema_version_state(rqst);
-  recv_set_schema_version_state(seqid);
+  int32_t seqid = send_get_serde(rqst);
+  recv_get_serde(_return, seqid);
 }
 
-int32_t 
ThriftHiveMetastoreConcurrentClient::send_set_schema_version_state(const 
SetSchemaVersionStateRequest& rqst)
+int32_t ThriftHiveMetastoreConcurrentClient::send_get_serde(const 
GetSerdeRequest& rqst)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("set_schema_version_state", 
::apache::thrift::protocol::T_CALL, cseqid);
+  oprot_->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_CALL, 
cseqid);
 
-  ThriftHiveMetastore_set_schema_version_state_pargs args;
+  ThriftHiveMetastore_get_serde_pargs args;
   args.rqst = &rqst;
   args.write(oprot_);
 
@@ -91315,7 +92157,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_set_schema_version_state(const
   return cseqid;
 }
 
-void ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const 
int32_t seqid)
+void ThriftHiveMetastoreConcurrentClient::recv_get_serde(SerDeInfo& _return, 
const int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -91344,7 +92186,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const in
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("set_schema_version_state") != 0) {
+      if (fname.compare("get_serde") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91353,11 +92195,17 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const in
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_set_schema_version_state_presult result;
+      ThriftHiveMetastore_get_serde_presult result;
+      result.success = &_return;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
 
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
       if (result.__isset.o1) {
         sentry.commit();
         throw result.o1;
@@ -91366,12 +92214,8 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const in
         sentry.commit();
         throw result.o2;
       }
-      if (result.__isset.o3) {
-        sentry.commit();
-        throw result.o3;
-      }
-      sentry.commit();
-      return;
+      // in a bad state, don't commit
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_serde failed: unknown result");
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -91381,20 +92225,22 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_set_schema_version_state(const in
   } // end while(true)
 }
 
-void ThriftHiveMetastoreConcurrentClient::add_serde(const SerDeInfo& serde)
+void 
ThriftHiveMetastoreConcurrentClient::get_lock_materialization_rebuild(LockResponse&
 _return, const std::string& dbName, const std::string& tableName, const 
int64_t txnId)
 {
-  int32_t seqid = send_add_serde(serde);
-  recv_add_serde(seqid);
+  int32_t seqid = send_get_lock_materialization_rebuild(dbName, tableName, 
txnId);
+  recv_get_lock_materialization_rebuild(_return, seqid);
 }
 
-int32_t ThriftHiveMetastoreConcurrentClient::send_add_serde(const SerDeInfo& 
serde)
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_lock_materialization_rebuild(const
 std::string& dbName, const std::string& tableName, const int64_t txnId)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("add_serde", ::apache::thrift::protocol::T_CALL, 
cseqid);
+  oprot_->writeMessageBegin("get_lock_materialization_rebuild", 
::apache::thrift::protocol::T_CALL, cseqid);
 
-  ThriftHiveMetastore_add_serde_pargs args;
-  args.serde = &serde;
+  ThriftHiveMetastore_get_lock_materialization_rebuild_pargs args;
+  args.dbName = &dbName;
+  args.tableName = &tableName;
+  args.txnId = &txnId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -91405,7 +92251,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_add_serde(const SerDeInfo& ser
   return cseqid;
 }
 
-void ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid)
+void 
ThriftHiveMetastoreConcurrentClient::recv_get_lock_materialization_rebuild(LockResponse&
 _return, const int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -91434,7 +92280,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid)
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("add_serde") != 0) {
+      if (fname.compare("get_lock_materialization_rebuild") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91443,21 +92289,19 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid)
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_add_serde_presult result;
+      ThriftHiveMetastore_get_lock_materialization_rebuild_presult result;
+      result.success = &_return;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
 
-      if (result.__isset.o1) {
-        sentry.commit();
-        throw result.o1;
-      }
-      if (result.__isset.o2) {
+      if (result.__isset.success) {
+        // _return pointer has now been filled
         sentry.commit();
-        throw result.o2;
+        return;
       }
-      sentry.commit();
-      return;
+      // in a bad state, don't commit
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_lock_materialization_rebuild failed: unknown result");
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);
@@ -91467,20 +92311,22 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_add_serde(const int32_t seqid)
   } // end while(true)
 }
 
-void ThriftHiveMetastoreConcurrentClient::get_serde(SerDeInfo& _return, const 
GetSerdeRequest& rqst)
+bool 
ThriftHiveMetastoreConcurrentClient::heartbeat_lock_materialization_rebuild(const
 std::string& dbName, const std::string& tableName, const int64_t txnId)
 {
-  int32_t seqid = send_get_serde(rqst);
-  recv_get_serde(_return, seqid);
+  int32_t seqid = send_heartbeat_lock_materialization_rebuild(dbName, 
tableName, txnId);
+  return recv_heartbeat_lock_materialization_rebuild(seqid);
 }
 
-int32_t ThriftHiveMetastoreConcurrentClient::send_get_serde(const 
GetSerdeRequest& rqst)
+int32_t 
ThriftHiveMetastoreConcurrentClient::send_heartbeat_lock_materialization_rebuild(const
 std::string& dbName, const std::string& tableName, const int64_t txnId)
 {
   int32_t cseqid = this->sync_.generateSeqId();
   ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);
-  oprot_->writeMessageBegin("get_serde", ::apache::thrift::protocol::T_CALL, 
cseqid);
+  oprot_->writeMessageBegin("heartbeat_lock_materialization_rebuild", 
::apache::thrift::protocol::T_CALL, cseqid);
 
-  ThriftHiveMetastore_get_serde_pargs args;
-  args.rqst = &rqst;
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs args;
+  args.dbName = &dbName;
+  args.tableName = &tableName;
+  args.txnId = &txnId;
   args.write(oprot_);
 
   oprot_->writeMessageEnd();
@@ -91491,7 +92337,7 @@ int32_t 
ThriftHiveMetastoreConcurrentClient::send_get_serde(const GetSerdeReques
   return cseqid;
 }
 
-void ThriftHiveMetastoreConcurrentClient::recv_get_serde(SerDeInfo& _return, 
const int32_t seqid)
+bool 
ThriftHiveMetastoreConcurrentClient::recv_heartbeat_lock_materialization_rebuild(const
 int32_t seqid)
 {
 
   int32_t rseqid = 0;
@@ -91520,7 +92366,7 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_serde(SerDeInfo& _return, con
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
       }
-      if (fname.compare("get_serde") != 0) {
+      if (fname.compare("heartbeat_lock_materialization_rebuild") != 0) {
         iprot_->skip(::apache::thrift::protocol::T_STRUCT);
         iprot_->readMessageEnd();
         iprot_->getTransport()->readEnd();
@@ -91529,27 +92375,19 @@ void 
ThriftHiveMetastoreConcurrentClient::recv_get_serde(SerDeInfo& _return, con
         using ::apache::thrift::protocol::TProtocolException;
         throw TProtocolException(TProtocolException::INVALID_DATA);
       }
-      ThriftHiveMetastore_get_serde_presult result;
+      bool _return;
+      ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult 
result;
       result.success = &_return;
       result.read(iprot_);
       iprot_->readMessageEnd();
       iprot_->getTransport()->readEnd();
 
       if (result.__isset.success) {
-        // _return pointer has now been filled
         sentry.commit();
-        return;
-      }
-      if (result.__isset.o1) {
-        sentry.commit();
-        throw result.o1;
-      }
-      if (result.__isset.o2) {
-        sentry.commit();
-        throw result.o2;
+        return _return;
       }
       // in a bad state, don't commit
-      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "get_serde failed: unknown result");
+      throw 
::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT,
 "heartbeat_lock_materialization_rebuild failed: unknown result");
     }
     // seqid != rseqid
     this->sync_.updatePending(fname, mtype, rseqid);

http://git-wip-us.apache.org/repos/asf/hive/blob/be420098/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h 
b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
index b9e8e24..802d8e3 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
@@ -222,6 +222,8 @@ class ThriftHiveMetastoreIf : virtual public  
::facebook::fb303::FacebookService
   virtual void set_schema_version_state(const SetSchemaVersionStateRequest& 
rqst) = 0;
   virtual void add_serde(const SerDeInfo& serde) = 0;
   virtual void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) = 0;
+  virtual void get_lock_materialization_rebuild(LockResponse& _return, const 
std::string& dbName, const std::string& tableName, const int64_t txnId) = 0;
+  virtual bool heartbeat_lock_materialization_rebuild(const std::string& 
dbName, const std::string& tableName, const int64_t txnId) = 0;
 };
 
 class ThriftHiveMetastoreIfFactory : virtual public  
::facebook::fb303::FacebookServiceIfFactory {
@@ -878,6 +880,13 @@ class ThriftHiveMetastoreNull : virtual public 
ThriftHiveMetastoreIf , virtual p
   void get_serde(SerDeInfo& /* _return */, const GetSerdeRequest& /* rqst */) {
     return;
   }
+  void get_lock_materialization_rebuild(LockResponse& /* _return */, const 
std::string& /* dbName */, const std::string& /* tableName */, const int64_t /* 
txnId */) {
+    return;
+  }
+  bool heartbeat_lock_materialization_rebuild(const std::string& /* dbName */, 
const std::string& /* tableName */, const int64_t /* txnId */) {
+    bool _return = false;
+    return _return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -25399,6 +25408,242 @@ class ThriftHiveMetastore_get_serde_presult {
 
 };
 
+typedef struct 
_ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset {
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset() : 
dbName(false), tableName(false), txnId(false) {}
+  bool dbName :1;
+  bool tableName :1;
+  bool txnId :1;
+} _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset;
+
+class ThriftHiveMetastore_get_lock_materialization_rebuild_args {
+ public:
+
+  ThriftHiveMetastore_get_lock_materialization_rebuild_args(const 
ThriftHiveMetastore_get_lock_materialization_rebuild_args&);
+  ThriftHiveMetastore_get_lock_materialization_rebuild_args& operator=(const 
ThriftHiveMetastore_get_lock_materialization_rebuild_args&);
+  ThriftHiveMetastore_get_lock_materialization_rebuild_args() : dbName(), 
tableName(), txnId(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_args() throw();
+  std::string dbName;
+  std::string tableName;
+  int64_t txnId;
+
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset __isset;
+
+  void __set_dbName(const std::string& val);
+
+  void __set_tableName(const std::string& val);
+
+  void __set_txnId(const int64_t val);
+
+  bool operator == (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_args & rhs) const
+  {
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(txnId == rhs.txnId))
+      return false;
+    return true;
+  }
+  bool operator != (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_lock_materialization_rebuild_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_pargs() 
throw();
+  const std::string* dbName;
+  const std::string* tableName;
+  const int64_t* txnId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct 
_ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset {
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset() : 
success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset;
+
+class ThriftHiveMetastore_get_lock_materialization_rebuild_result {
+ public:
+
+  ThriftHiveMetastore_get_lock_materialization_rebuild_result(const 
ThriftHiveMetastore_get_lock_materialization_rebuild_result&);
+  ThriftHiveMetastore_get_lock_materialization_rebuild_result& operator=(const 
ThriftHiveMetastore_get_lock_materialization_rebuild_result&);
+  ThriftHiveMetastore_get_lock_materialization_rebuild_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_result() 
throw();
+  LockResponse success;
+
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset __isset;
+
+  void __set_success(const LockResponse& val);
+
+  bool operator == (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const 
ThriftHiveMetastore_get_lock_materialization_rebuild_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct 
_ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset {
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset() : 
success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset;
+
+class ThriftHiveMetastore_get_lock_materialization_rebuild_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_presult() 
throw();
+  LockResponse* success;
+
+  _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct 
_ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset {
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset() : 
dbName(false), tableName(false), txnId(false) {}
+  bool dbName :1;
+  bool tableName :1;
+  bool txnId :1;
+} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset;
+
+class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args {
+ public:
+
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args(const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&);
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args& 
operator=(const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&);
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() : 
dbName(), tableName(), txnId(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() 
throw();
+  std::string dbName;
+  std::string tableName;
+  int64_t txnId;
+
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset 
__isset;
+
+  void __set_dbName(const std::string& val);
+
+  void __set_tableName(const std::string& val);
+
+  void __set_txnId(const int64_t val);
+
+  bool operator == (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & rhs) const
+  {
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(tableName == rhs.tableName))
+      return false;
+    if (!(txnId == rhs.txnId))
+      return false;
+    return true;
+  }
+  bool operator != (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs() 
throw();
+  const std::string* dbName;
+  const std::string* tableName;
+  const int64_t* txnId;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct 
_ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset {
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset() 
: success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset;
+
+class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result {
+ public:
+
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result(const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&);
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result& 
operator=(const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&);
+  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() : 
success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() 
throw();
+  bool success;
+
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset 
__isset;
+
+  void __set_success(const bool val);
+
+  bool operator == (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const 
ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct 
_ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset {
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset() 
: success(false) {}
+  bool success :1;
+} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset;
+
+class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult {
+ public:
+
+
+  virtual 
~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult() throw();
+  bool* success;
+
+  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_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) :
@@ -26010,6 +26255,12 @@ class ThriftHiveMetastoreClient : virtual public 
ThriftHiveMetastoreIf, public
   void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst);
   void send_get_serde(const GetSerdeRequest& rqst);
   void recv_get_serde(SerDeInfo& _return);
+  void get_lock_materialization_rebuild(LockResponse& _return, const 
std::string& dbName, const std::string& tableName, const int64_t txnId);
+  void send_get_lock_materialization_rebuild(const std::string& dbName, const 
std::string& tableName, const int64_t txnId);
+  void recv_get_lock_materialization_rebuild(LockResponse& _return);
+  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const 
std::string& tableName, const int64_t txnId);
+  void send_heartbeat_lock_materialization_rebuild(const std::string& dbName, 
const std::string& tableName, const int64_t txnId);
+  bool recv_heartbeat_lock_materialization_rebuild();
 };
 
 class ThriftHiveMetastoreProcessor : public  
::facebook::fb303::FacebookServiceProcessor {
@@ -26220,6 +26471,8 @@ class ThriftHiveMetastoreProcessor : public  
::facebook::fb303::FacebookServiceP
   void process_set_schema_version_state(int32_t seqid, 
::apache::thrift::protocol::TProtocol* iprot, 
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_add_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* 
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_get_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* 
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_lock_materialization_rebuild(int32_t seqid, 
::apache::thrift::protocol::TProtocol* iprot, 
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_heartbeat_lock_materialization_rebuild(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),
@@ -26424,6 +26677,8 @@ class ThriftHiveMetastoreProcessor : public  
::facebook::fb303::FacebookServiceP
     processMap_["set_schema_version_state"] = 
&ThriftHiveMetastoreProcessor::process_set_schema_version_state;
     processMap_["add_serde"] = 
&ThriftHiveMetastoreProcessor::process_add_serde;
     processMap_["get_serde"] = 
&ThriftHiveMetastoreProcessor::process_get_serde;
+    processMap_["get_lock_materialization_rebuild"] = 
&ThriftHiveMetastoreProcessor::process_get_lock_materialization_rebuild;
+    processMap_["heartbeat_lock_materialization_rebuild"] = 
&ThriftHiveMetastoreProcessor::process_heartbeat_lock_materialization_rebuild;
   }
 
   virtual ~ThriftHiveMetastoreProcessor() {}
@@ -28380,6 +28635,25 @@ class ThriftHiveMetastoreMultiface : virtual public 
ThriftHiveMetastoreIf, publi
     return;
   }
 
+  void get_lock_materialization_rebuild(LockResponse& _return, const 
std::string& dbName, const std::string& tableName, const int64_t txnId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, 
txnId);
+    }
+    ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, 
txnId);
+    return;
+  }
+
+  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const 
std::string& tableName, const int64_t txnId) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, tableName, 
txnId);
+    }
+    return ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, 
tableName, txnId);
+  }
+
 };
 
 // The 'concurrent' client is a thread safe client that correctly handles
@@ -28996,6 +29270,12 @@ class ThriftHiveMetastoreConcurrentClient : virtual 
public ThriftHiveMetastoreIf
   void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst);
   int32_t send_get_serde(const GetSerdeRequest& rqst);
   void recv_get_serde(SerDeInfo& _return, const int32_t seqid);
+  void get_lock_materialization_rebuild(LockResponse& _return, const 
std::string& dbName, const std::string& tableName, const int64_t txnId);
+  int32_t send_get_lock_materialization_rebuild(const std::string& dbName, 
const std::string& tableName, const int64_t txnId);
+  void recv_get_lock_materialization_rebuild(LockResponse& _return, const 
int32_t seqid);
+  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const 
std::string& tableName, const int64_t txnId);
+  int32_t send_heartbeat_lock_materialization_rebuild(const std::string& 
dbName, const std::string& tableName, const int64_t txnId);
+  bool recv_heartbeat_lock_materialization_rebuild(const int32_t seqid);
 };
 
 #ifdef _WIN32

http://git-wip-us.apache.org/repos/asf/hive/blob/be420098/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
 
b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
index cfec64f..c0a39f8 100644
--- 
a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
+++ 
b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
@@ -1022,6 +1022,16 @@ class ThriftHiveMetastoreHandler : virtual public 
ThriftHiveMetastoreIf {
     printf("get_serde\n");
   }
 
+  void get_lock_materialization_rebuild(LockResponse& _return, const 
std::string& dbName, const std::string& tableName, const int64_t txnId) {
+    // Your implementation goes here
+    printf("get_lock_materialization_rebuild\n");
+  }
+
+  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const 
std::string& tableName, const int64_t txnId) {
+    // Your implementation goes here
+    printf("heartbeat_lock_materialization_rebuild\n");
+  }
+
 };
 
 int main(int argc, char **argv) {

http://git-wip-us.apache.org/repos/asf/hive/blob/be420098/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp 
b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 383cb9b..1904047 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -24413,6 +24413,12 @@ __isset.validTxnList = true;
 
 void Materialization::__set_invalidationTime(const int64_t val) {
   this->invalidationTime = val;
+__isset.invalidationTime = true;
+}
+
+void Materialization::__set_sourceTablesUpdateDeleteModified(const bool val) {
+  this->sourceTablesUpdateDeleteModified = val;
+__isset.sourceTablesUpdateDeleteModified = true;
 }
 
 uint32_t Materialization::read(::apache::thrift::protocol::TProtocol* iprot) {
@@ -24428,7 +24434,6 @@ uint32_t 
Materialization::read(::apache::thrift::protocol::TProtocol* iprot) {
   using ::apache::thrift::protocol::TProtocolException;
 
   bool isset_tablesUsed = false;
-  bool isset_invalidationTime = false;
 
   while (true)
   {
@@ -24470,7 +24475,15 @@ uint32_t 
Materialization::read(::apache::thrift::protocol::TProtocol* iprot) {
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I64) {
           xfer += iprot->readI64(this->invalidationTime);
-          isset_invalidationTime = true;
+          this->__isset.invalidationTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->sourceTablesUpdateDeleteModified);
+          this->__isset.sourceTablesUpdateDeleteModified = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -24486,8 +24499,6 @@ uint32_t 
Materialization::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   if (!isset_tablesUsed)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_invalidationTime)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
@@ -24513,10 +24524,16 @@ uint32_t 
Materialization::write(::apache::thrift::protocol::TProtocol* oprot) co
     xfer += oprot->writeString(this->validTxnList);
     xfer += oprot->writeFieldEnd();
   }
-  xfer += oprot->writeFieldBegin("invalidationTime", 
::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->invalidationTime);
-  xfer += oprot->writeFieldEnd();
-
+  if (this->__isset.invalidationTime) {
+    xfer += oprot->writeFieldBegin("invalidationTime", 
::apache::thrift::protocol::T_I64, 3);
+    xfer += oprot->writeI64(this->invalidationTime);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.sourceTablesUpdateDeleteModified) {
+    xfer += oprot->writeFieldBegin("sourceTablesUpdateDeleteModified", 
::apache::thrift::protocol::T_BOOL, 4);
+    xfer += oprot->writeBool(this->sourceTablesUpdateDeleteModified);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -24527,6 +24544,7 @@ void swap(Materialization &a, Materialization &b) {
   swap(a.tablesUsed, b.tablesUsed);
   swap(a.validTxnList, b.validTxnList);
   swap(a.invalidationTime, b.invalidationTime);
+  swap(a.sourceTablesUpdateDeleteModified, b.sourceTablesUpdateDeleteModified);
   swap(a.__isset, b.__isset);
 }
 
@@ -24534,12 +24552,14 @@ Materialization::Materialization(const 
Materialization& other978) {
   tablesUsed = other978.tablesUsed;
   validTxnList = other978.validTxnList;
   invalidationTime = other978.invalidationTime;
+  sourceTablesUpdateDeleteModified = other978.sourceTablesUpdateDeleteModified;
   __isset = other978.__isset;
 }
 Materialization& Materialization::operator=(const Materialization& other979) {
   tablesUsed = other979.tablesUsed;
   validTxnList = other979.validTxnList;
   invalidationTime = other979.invalidationTime;
+  sourceTablesUpdateDeleteModified = other979.sourceTablesUpdateDeleteModified;
   __isset = other979.__isset;
   return *this;
 }
@@ -24548,7 +24568,8 @@ void Materialization::printTo(std::ostream& out) const {
   out << "Materialization(";
   out << "tablesUsed=" << to_string(tablesUsed);
   out << ", " << "validTxnList="; (__isset.validTxnList ? (out << 
to_string(validTxnList)) : (out << "<null>"));
-  out << ", " << "invalidationTime=" << to_string(invalidationTime);
+  out << ", " << "invalidationTime="; (__isset.invalidationTime ? (out << 
to_string(invalidationTime)) : (out << "<null>"));
+  out << ", " << "sourceTablesUpdateDeleteModified="; 
(__isset.sourceTablesUpdateDeleteModified ? (out << 
to_string(sourceTablesUpdateDeleteModified)) : (out << "<null>"));
   out << ")";
 }
 

http://git-wip-us.apache.org/repos/asf/hive/blob/be420098/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h 
b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index 086cfe9..55a97de 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -10066,8 +10066,10 @@ inline std::ostream& operator<<(std::ostream& out, 
const TableMeta& obj)
 }
 
 typedef struct _Materialization__isset {
-  _Materialization__isset() : validTxnList(false) {}
+  _Materialization__isset() : validTxnList(false), invalidationTime(false), 
sourceTablesUpdateDeleteModified(false) {}
   bool validTxnList :1;
+  bool invalidationTime :1;
+  bool sourceTablesUpdateDeleteModified :1;
 } _Materialization__isset;
 
 class Materialization {
@@ -10075,13 +10077,14 @@ class Materialization {
 
   Materialization(const Materialization&);
   Materialization& operator=(const Materialization&);
-  Materialization() : validTxnList(), invalidationTime(0) {
+  Materialization() : validTxnList(), invalidationTime(0), 
sourceTablesUpdateDeleteModified(0) {
   }
 
   virtual ~Materialization() throw();
   std::set<std::string>  tablesUsed;
   std::string validTxnList;
   int64_t invalidationTime;
+  bool sourceTablesUpdateDeleteModified;
 
   _Materialization__isset __isset;
 
@@ -10091,6 +10094,8 @@ class Materialization {
 
   void __set_invalidationTime(const int64_t val);
 
+  void __set_sourceTablesUpdateDeleteModified(const bool val);
+
   bool operator == (const Materialization & rhs) const
   {
     if (!(tablesUsed == rhs.tablesUsed))
@@ -10099,7 +10104,13 @@ class Materialization {
       return false;
     else if (__isset.validTxnList && !(validTxnList == rhs.validTxnList))
       return false;
-    if (!(invalidationTime == rhs.invalidationTime))
+    if (__isset.invalidationTime != rhs.__isset.invalidationTime)
+      return false;
+    else if (__isset.invalidationTime && !(invalidationTime == 
rhs.invalidationTime))
+      return false;
+    if (__isset.sourceTablesUpdateDeleteModified != 
rhs.__isset.sourceTablesUpdateDeleteModified)
+      return false;
+    else if (__isset.sourceTablesUpdateDeleteModified && 
!(sourceTablesUpdateDeleteModified == rhs.sourceTablesUpdateDeleteModified))
       return false;
     return true;
   }

Reply via email to