You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by jc...@apache.org on 2018/04/10 09:29:43 UTC
[05/24] hive git commit: HIVE-18839: Implement incremental rebuild
for materialized views (only insert operations in source tables) (Jesus
Camacho Rodriguez, reviewed by Ashutosh Chauhan)
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;
}