http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/ThriftHive.cpp ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/ThriftHive.cpp b/service/src/gen/thrift/gen-cpp/ThriftHive.cpp index 8935c04..a5448f0 100644 --- a/service/src/gen/thrift/gen-cpp/ThriftHive.cpp +++ b/service/src/gen/thrift/gen-cpp/ThriftHive.cpp @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -15,6 +15,7 @@ ThriftHive_execute_args::~ThriftHive_execute_args() throw() { uint32_t ThriftHive_execute_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; @@ -55,7 +56,7 @@ uint32_t ThriftHive_execute_args::read(::apache::thrift::protocol::TProtocol* ip uint32_t ThriftHive_execute_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_execute_args"); xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1); @@ -64,7 +65,6 @@ uint32_t ThriftHive_execute_args::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -75,7 +75,7 @@ ThriftHive_execute_pargs::~ThriftHive_execute_pargs() throw() { uint32_t ThriftHive_execute_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_execute_pargs"); xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1); @@ -84,7 +84,6 @@ uint32_t ThriftHive_execute_pargs::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -95,6 +94,7 @@ ThriftHive_execute_result::~ThriftHive_execute_result() throw() { uint32_t ThriftHive_execute_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; @@ -156,6 +156,7 @@ ThriftHive_execute_presult::~ThriftHive_execute_presult() throw() { uint32_t ThriftHive_execute_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; @@ -201,6 +202,7 @@ ThriftHive_fetchOne_args::~ThriftHive_fetchOne_args() throw() { uint32_t ThriftHive_fetchOne_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; @@ -228,12 +230,11 @@ uint32_t ThriftHive_fetchOne_args::read(::apache::thrift::protocol::TProtocol* i uint32_t ThriftHive_fetchOne_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchOne_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -244,12 +245,11 @@ ThriftHive_fetchOne_pargs::~ThriftHive_fetchOne_pargs() throw() { uint32_t ThriftHive_fetchOne_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchOne_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -260,6 +260,7 @@ ThriftHive_fetchOne_result::~ThriftHive_fetchOne_result() throw() { uint32_t ThriftHive_fetchOne_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; @@ -333,6 +334,7 @@ ThriftHive_fetchOne_presult::~ThriftHive_fetchOne_presult() throw() { uint32_t ThriftHive_fetchOne_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; @@ -386,6 +388,7 @@ ThriftHive_fetchN_args::~ThriftHive_fetchN_args() throw() { uint32_t ThriftHive_fetchN_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; @@ -426,7 +429,7 @@ uint32_t ThriftHive_fetchN_args::read(::apache::thrift::protocol::TProtocol* ipr uint32_t ThriftHive_fetchN_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchN_args"); xfer += oprot->writeFieldBegin("numRows", ::apache::thrift::protocol::T_I32, 1); @@ -435,7 +438,6 @@ uint32_t ThriftHive_fetchN_args::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -446,7 +448,7 @@ ThriftHive_fetchN_pargs::~ThriftHive_fetchN_pargs() throw() { uint32_t ThriftHive_fetchN_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchN_pargs"); xfer += oprot->writeFieldBegin("numRows", ::apache::thrift::protocol::T_I32, 1); @@ -455,7 +457,6 @@ uint32_t ThriftHive_fetchN_pargs::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -466,6 +467,7 @@ ThriftHive_fetchN_result::~ThriftHive_fetchN_result() throw() { uint32_t ThriftHive_fetchN_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; @@ -559,6 +561,7 @@ ThriftHive_fetchN_presult::~ThriftHive_fetchN_presult() throw() { uint32_t ThriftHive_fetchN_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; @@ -624,6 +627,7 @@ ThriftHive_fetchAll_args::~ThriftHive_fetchAll_args() throw() { uint32_t ThriftHive_fetchAll_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; @@ -651,12 +655,11 @@ uint32_t ThriftHive_fetchAll_args::read(::apache::thrift::protocol::TProtocol* i uint32_t ThriftHive_fetchAll_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchAll_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -667,12 +670,11 @@ ThriftHive_fetchAll_pargs::~ThriftHive_fetchAll_pargs() throw() { uint32_t ThriftHive_fetchAll_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_fetchAll_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -683,6 +685,7 @@ ThriftHive_fetchAll_result::~ThriftHive_fetchAll_result() throw() { uint32_t ThriftHive_fetchAll_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; @@ -776,6 +779,7 @@ ThriftHive_fetchAll_presult::~ThriftHive_fetchAll_presult() throw() { uint32_t ThriftHive_fetchAll_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; @@ -841,6 +845,7 @@ ThriftHive_getSchema_args::~ThriftHive_getSchema_args() throw() { uint32_t ThriftHive_getSchema_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; @@ -868,12 +873,11 @@ uint32_t ThriftHive_getSchema_args::read(::apache::thrift::protocol::TProtocol* uint32_t ThriftHive_getSchema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getSchema_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -884,12 +888,11 @@ ThriftHive_getSchema_pargs::~ThriftHive_getSchema_pargs() throw() { uint32_t ThriftHive_getSchema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getSchema_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -900,6 +903,7 @@ ThriftHive_getSchema_result::~ThriftHive_getSchema_result() throw() { uint32_t ThriftHive_getSchema_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; @@ -973,6 +977,7 @@ ThriftHive_getSchema_presult::~ThriftHive_getSchema_presult() throw() { uint32_t ThriftHive_getSchema_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; @@ -1026,6 +1031,7 @@ ThriftHive_getThriftSchema_args::~ThriftHive_getThriftSchema_args() throw() { uint32_t ThriftHive_getThriftSchema_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; @@ -1053,12 +1059,11 @@ uint32_t ThriftHive_getThriftSchema_args::read(::apache::thrift::protocol::TProt uint32_t ThriftHive_getThriftSchema_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getThriftSchema_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1069,12 +1074,11 @@ ThriftHive_getThriftSchema_pargs::~ThriftHive_getThriftSchema_pargs() throw() { uint32_t ThriftHive_getThriftSchema_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getThriftSchema_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1085,6 +1089,7 @@ ThriftHive_getThriftSchema_result::~ThriftHive_getThriftSchema_result() throw() uint32_t ThriftHive_getThriftSchema_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; @@ -1158,6 +1163,7 @@ ThriftHive_getThriftSchema_presult::~ThriftHive_getThriftSchema_presult() throw( uint32_t ThriftHive_getThriftSchema_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; @@ -1211,6 +1217,7 @@ ThriftHive_getClusterStatus_args::~ThriftHive_getClusterStatus_args() throw() { uint32_t ThriftHive_getClusterStatus_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; @@ -1238,12 +1245,11 @@ uint32_t ThriftHive_getClusterStatus_args::read(::apache::thrift::protocol::TPro uint32_t ThriftHive_getClusterStatus_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getClusterStatus_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1254,12 +1260,11 @@ ThriftHive_getClusterStatus_pargs::~ThriftHive_getClusterStatus_pargs() throw() uint32_t ThriftHive_getClusterStatus_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getClusterStatus_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1270,6 +1275,7 @@ ThriftHive_getClusterStatus_result::~ThriftHive_getClusterStatus_result() throw( uint32_t ThriftHive_getClusterStatus_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; @@ -1343,6 +1349,7 @@ ThriftHive_getClusterStatus_presult::~ThriftHive_getClusterStatus_presult() thro uint32_t ThriftHive_getClusterStatus_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; @@ -1396,6 +1403,7 @@ ThriftHive_getQueryPlan_args::~ThriftHive_getQueryPlan_args() throw() { uint32_t ThriftHive_getQueryPlan_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; @@ -1423,12 +1431,11 @@ uint32_t ThriftHive_getQueryPlan_args::read(::apache::thrift::protocol::TProtoco uint32_t ThriftHive_getQueryPlan_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getQueryPlan_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1439,12 +1446,11 @@ ThriftHive_getQueryPlan_pargs::~ThriftHive_getQueryPlan_pargs() throw() { uint32_t ThriftHive_getQueryPlan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_getQueryPlan_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1455,6 +1461,7 @@ ThriftHive_getQueryPlan_result::~ThriftHive_getQueryPlan_result() throw() { uint32_t ThriftHive_getQueryPlan_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; @@ -1528,6 +1535,7 @@ ThriftHive_getQueryPlan_presult::~ThriftHive_getQueryPlan_presult() throw() { uint32_t ThriftHive_getQueryPlan_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; @@ -1581,6 +1589,7 @@ ThriftHive_clean_args::~ThriftHive_clean_args() throw() { uint32_t ThriftHive_clean_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; @@ -1608,12 +1617,11 @@ uint32_t ThriftHive_clean_args::read(::apache::thrift::protocol::TProtocol* ipro uint32_t ThriftHive_clean_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_clean_args"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1624,12 +1632,11 @@ ThriftHive_clean_pargs::~ThriftHive_clean_pargs() throw() { uint32_t ThriftHive_clean_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ThriftHive_clean_pargs"); xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -1640,6 +1647,7 @@ ThriftHive_clean_result::~ThriftHive_clean_result() throw() { uint32_t ThriftHive_clean_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; @@ -1683,6 +1691,7 @@ ThriftHive_clean_presult::~ThriftHive_clean_presult() throw() { uint32_t ThriftHive_clean_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; @@ -2761,5 +2770,775 @@ void ThriftHiveProcessor::process_clean(int32_t seqid, ::apache::thrift::protoco ::boost::shared_ptr< ::apache::thrift::TProcessor > processor(new ThriftHiveProcessor(handler)); return processor; } + +void ThriftHiveConcurrentClient::execute(const std::string& query) +{ + int32_t seqid = send_execute(query); + recv_execute(seqid); +} + +int32_t ThriftHiveConcurrentClient::send_execute(const std::string& query) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("execute", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_execute_pargs args; + args.query = &query; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_execute(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("execute") != 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); + } + ThriftHive_execute_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.ex) { + sentry.commit(); + throw result.ex; + } + 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 ThriftHiveConcurrentClient::fetchOne(std::string& _return) +{ + int32_t seqid = send_fetchOne(); + recv_fetchOne(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_fetchOne() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("fetchOne", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_fetchOne_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_fetchOne(std::string& _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("fetchOne") != 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); + } + ThriftHive_fetchOne_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fetchOne 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 ThriftHiveConcurrentClient::fetchN(std::vector<std::string> & _return, const int32_t numRows) +{ + int32_t seqid = send_fetchN(numRows); + recv_fetchN(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_fetchN(const int32_t numRows) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("fetchN", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_fetchN_pargs args; + args.numRows = &numRows; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_fetchN(std::vector<std::string> & _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("fetchN") != 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); + } + ThriftHive_fetchN_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fetchN 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 ThriftHiveConcurrentClient::fetchAll(std::vector<std::string> & _return) +{ + int32_t seqid = send_fetchAll(); + recv_fetchAll(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_fetchAll() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("fetchAll", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_fetchAll_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_fetchAll(std::vector<std::string> & _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("fetchAll") != 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); + } + ThriftHive_fetchAll_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "fetchAll 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 ThriftHiveConcurrentClient::getSchema( ::Apache::Hadoop::Hive::Schema& _return) +{ + int32_t seqid = send_getSchema(); + recv_getSchema(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_getSchema() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getSchema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_getSchema_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_getSchema( ::Apache::Hadoop::Hive::Schema& _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("getSchema") != 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); + } + ThriftHive_getSchema_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getSchema 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 ThriftHiveConcurrentClient::getThriftSchema( ::Apache::Hadoop::Hive::Schema& _return) +{ + int32_t seqid = send_getThriftSchema(); + recv_getThriftSchema(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_getThriftSchema() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getThriftSchema", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_getThriftSchema_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_getThriftSchema( ::Apache::Hadoop::Hive::Schema& _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("getThriftSchema") != 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); + } + ThriftHive_getThriftSchema_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getThriftSchema 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 ThriftHiveConcurrentClient::getClusterStatus(HiveClusterStatus& _return) +{ + int32_t seqid = send_getClusterStatus(); + recv_getClusterStatus(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_getClusterStatus() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getClusterStatus", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_getClusterStatus_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_getClusterStatus(HiveClusterStatus& _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("getClusterStatus") != 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); + } + ThriftHive_getClusterStatus_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getClusterStatus 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 ThriftHiveConcurrentClient::getQueryPlan( ::Apache::Hadoop::Hive::QueryPlan& _return) +{ + int32_t seqid = send_getQueryPlan(); + recv_getQueryPlan(_return, seqid); +} + +int32_t ThriftHiveConcurrentClient::send_getQueryPlan() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("getQueryPlan", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_getQueryPlan_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_getQueryPlan( ::Apache::Hadoop::Hive::QueryPlan& _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("getQueryPlan") != 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); + } + ThriftHive_getQueryPlan_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.ex) { + sentry.commit(); + throw result.ex; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getQueryPlan 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 ThriftHiveConcurrentClient::clean() +{ + int32_t seqid = send_clean(); + recv_clean(seqid); +} + +int32_t ThriftHiveConcurrentClient::send_clean() +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("clean", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHive_clean_pargs args; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +void ThriftHiveConcurrentClient::recv_clean(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("clean") != 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); + } + ThriftHive_clean_presult result; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + 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) +} + }}} // namespace
http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/ThriftHive.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/ThriftHive.h b/service/src/gen/thrift/gen-cpp/ThriftHive.h index e610e50..902bd4b 100644 --- a/service/src/gen/thrift/gen-cpp/ThriftHive.h +++ b/service/src/gen/thrift/gen-cpp/ThriftHive.h @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -8,11 +8,17 @@ #define ThriftHive_H #include <thrift/TDispatchProcessor.h> +#include <thrift/async/TConcurrentClientSyncInfo.h> #include "hive_service_types.h" #include "ThriftHiveMetastore.h" namespace Apache { namespace Hadoop { namespace Hive { +#ifdef _WIN32 + #pragma warning( push ) + #pragma warning (disable : 4250 ) //inheriting methods via dominance +#endif + class ThriftHiveIf : virtual public ::Apache::Hadoop::Hive::ThriftHiveMetastoreIf { public: virtual ~ThriftHiveIf() {} @@ -91,9 +97,6 @@ typedef struct _ThriftHive_execute_args__isset { class ThriftHive_execute_args { public: - static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; - static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; - ThriftHive_execute_args(const ThriftHive_execute_args&); ThriftHive_execute_args& operator=(const ThriftHive_execute_args&); ThriftHive_execute_args() : query() { @@ -121,23 +124,18 @@ class ThriftHive_execute_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_execute_args& obj); }; class ThriftHive_execute_pargs { public: - static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; - static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; - virtual ~ThriftHive_execute_pargs() throw(); const std::string* query; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_execute_pargs& obj); }; typedef struct _ThriftHive_execute_result__isset { @@ -148,9 +146,6 @@ typedef struct _ThriftHive_execute_result__isset { class ThriftHive_execute_result { public: - static const char* ascii_fingerprint; // = "6AC6FD61CA5E3524E0174B0B96D6F9C0"; - static const uint8_t binary_fingerprint[16]; // = {0x6A,0xC6,0xFD,0x61,0xCA,0x5E,0x35,0x24,0xE0,0x17,0x4B,0x0B,0x96,0xD6,0xF9,0xC0}; - ThriftHive_execute_result(const ThriftHive_execute_result&); ThriftHive_execute_result& operator=(const ThriftHive_execute_result&); ThriftHive_execute_result() { @@ -178,7 +173,6 @@ class ThriftHive_execute_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_execute_result& obj); }; typedef struct _ThriftHive_execute_presult__isset { @@ -189,9 +183,6 @@ typedef struct _ThriftHive_execute_presult__isset { class ThriftHive_execute_presult { public: - static const char* ascii_fingerprint; // = "6AC6FD61CA5E3524E0174B0B96D6F9C0"; - static const uint8_t binary_fingerprint[16]; // = {0x6A,0xC6,0xFD,0x61,0xCA,0x5E,0x35,0x24,0xE0,0x17,0x4B,0x0B,0x96,0xD6,0xF9,0xC0}; - virtual ~ThriftHive_execute_presult() throw(); HiveServerException ex; @@ -200,16 +191,12 @@ class ThriftHive_execute_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_execute_presult& obj); }; class ThriftHive_fetchOne_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_fetchOne_args(const ThriftHive_fetchOne_args&); ThriftHive_fetchOne_args& operator=(const ThriftHive_fetchOne_args&); ThriftHive_fetchOne_args() { @@ -230,22 +217,17 @@ class ThriftHive_fetchOne_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchOne_args& obj); }; class ThriftHive_fetchOne_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_fetchOne_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchOne_pargs& obj); }; typedef struct _ThriftHive_fetchOne_result__isset { @@ -257,9 +239,6 @@ typedef struct _ThriftHive_fetchOne_result__isset { class ThriftHive_fetchOne_result { public: - static const char* ascii_fingerprint; // = "BD5C3537D3AE5C0248BD3B45C053AE32"; - static const uint8_t binary_fingerprint[16]; // = {0xBD,0x5C,0x35,0x37,0xD3,0xAE,0x5C,0x02,0x48,0xBD,0x3B,0x45,0xC0,0x53,0xAE,0x32}; - ThriftHive_fetchOne_result(const ThriftHive_fetchOne_result&); ThriftHive_fetchOne_result& operator=(const ThriftHive_fetchOne_result&); ThriftHive_fetchOne_result() : success() { @@ -292,7 +271,6 @@ class ThriftHive_fetchOne_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchOne_result& obj); }; typedef struct _ThriftHive_fetchOne_presult__isset { @@ -304,9 +282,6 @@ typedef struct _ThriftHive_fetchOne_presult__isset { class ThriftHive_fetchOne_presult { public: - static const char* ascii_fingerprint; // = "BD5C3537D3AE5C0248BD3B45C053AE32"; - static const uint8_t binary_fingerprint[16]; // = {0xBD,0x5C,0x35,0x37,0xD3,0xAE,0x5C,0x02,0x48,0xBD,0x3B,0x45,0xC0,0x53,0xAE,0x32}; - virtual ~ThriftHive_fetchOne_presult() throw(); std::string* success; @@ -316,7 +291,6 @@ class ThriftHive_fetchOne_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchOne_presult& obj); }; typedef struct _ThriftHive_fetchN_args__isset { @@ -327,9 +301,6 @@ typedef struct _ThriftHive_fetchN_args__isset { class ThriftHive_fetchN_args { public: - static const char* ascii_fingerprint; // = "E86CACEB22240450EDCBEFC3A83970E4"; - static const uint8_t binary_fingerprint[16]; // = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4}; - ThriftHive_fetchN_args(const ThriftHive_fetchN_args&); ThriftHive_fetchN_args& operator=(const ThriftHive_fetchN_args&); ThriftHive_fetchN_args() : numRows(0) { @@ -357,23 +328,18 @@ class ThriftHive_fetchN_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchN_args& obj); }; class ThriftHive_fetchN_pargs { public: - static const char* ascii_fingerprint; // = "E86CACEB22240450EDCBEFC3A83970E4"; - static const uint8_t binary_fingerprint[16]; // = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4}; - virtual ~ThriftHive_fetchN_pargs() throw(); const int32_t* numRows; uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchN_pargs& obj); }; typedef struct _ThriftHive_fetchN_result__isset { @@ -385,9 +351,6 @@ typedef struct _ThriftHive_fetchN_result__isset { class ThriftHive_fetchN_result { public: - static const char* ascii_fingerprint; // = "EB142A6BE66D8EE6065D07106EABD55D"; - static const uint8_t binary_fingerprint[16]; // = {0xEB,0x14,0x2A,0x6B,0xE6,0x6D,0x8E,0xE6,0x06,0x5D,0x07,0x10,0x6E,0xAB,0xD5,0x5D}; - ThriftHive_fetchN_result(const ThriftHive_fetchN_result&); ThriftHive_fetchN_result& operator=(const ThriftHive_fetchN_result&); ThriftHive_fetchN_result() { @@ -420,7 +383,6 @@ class ThriftHive_fetchN_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchN_result& obj); }; typedef struct _ThriftHive_fetchN_presult__isset { @@ -432,9 +394,6 @@ typedef struct _ThriftHive_fetchN_presult__isset { class ThriftHive_fetchN_presult { public: - static const char* ascii_fingerprint; // = "EB142A6BE66D8EE6065D07106EABD55D"; - static const uint8_t binary_fingerprint[16]; // = {0xEB,0x14,0x2A,0x6B,0xE6,0x6D,0x8E,0xE6,0x06,0x5D,0x07,0x10,0x6E,0xAB,0xD5,0x5D}; - virtual ~ThriftHive_fetchN_presult() throw(); std::vector<std::string> * success; @@ -444,16 +403,12 @@ class ThriftHive_fetchN_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchN_presult& obj); }; class ThriftHive_fetchAll_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_fetchAll_args(const ThriftHive_fetchAll_args&); ThriftHive_fetchAll_args& operator=(const ThriftHive_fetchAll_args&); ThriftHive_fetchAll_args() { @@ -474,22 +429,17 @@ class ThriftHive_fetchAll_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchAll_args& obj); }; class ThriftHive_fetchAll_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_fetchAll_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchAll_pargs& obj); }; typedef struct _ThriftHive_fetchAll_result__isset { @@ -501,9 +451,6 @@ typedef struct _ThriftHive_fetchAll_result__isset { class ThriftHive_fetchAll_result { public: - static const char* ascii_fingerprint; // = "EB142A6BE66D8EE6065D07106EABD55D"; - static const uint8_t binary_fingerprint[16]; // = {0xEB,0x14,0x2A,0x6B,0xE6,0x6D,0x8E,0xE6,0x06,0x5D,0x07,0x10,0x6E,0xAB,0xD5,0x5D}; - ThriftHive_fetchAll_result(const ThriftHive_fetchAll_result&); ThriftHive_fetchAll_result& operator=(const ThriftHive_fetchAll_result&); ThriftHive_fetchAll_result() { @@ -536,7 +483,6 @@ class ThriftHive_fetchAll_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchAll_result& obj); }; typedef struct _ThriftHive_fetchAll_presult__isset { @@ -548,9 +494,6 @@ typedef struct _ThriftHive_fetchAll_presult__isset { class ThriftHive_fetchAll_presult { public: - static const char* ascii_fingerprint; // = "EB142A6BE66D8EE6065D07106EABD55D"; - static const uint8_t binary_fingerprint[16]; // = {0xEB,0x14,0x2A,0x6B,0xE6,0x6D,0x8E,0xE6,0x06,0x5D,0x07,0x10,0x6E,0xAB,0xD5,0x5D}; - virtual ~ThriftHive_fetchAll_presult() throw(); std::vector<std::string> * success; @@ -560,16 +503,12 @@ class ThriftHive_fetchAll_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_fetchAll_presult& obj); }; class ThriftHive_getSchema_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_getSchema_args(const ThriftHive_getSchema_args&); ThriftHive_getSchema_args& operator=(const ThriftHive_getSchema_args&); ThriftHive_getSchema_args() { @@ -590,22 +529,17 @@ class ThriftHive_getSchema_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getSchema_args& obj); }; class ThriftHive_getSchema_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_getSchema_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getSchema_pargs& obj); }; typedef struct _ThriftHive_getSchema_result__isset { @@ -617,9 +551,6 @@ typedef struct _ThriftHive_getSchema_result__isset { class ThriftHive_getSchema_result { public: - static const char* ascii_fingerprint; // = "FCFAE75CC7093F1A3926C2AD58A6FFD1"; - static const uint8_t binary_fingerprint[16]; // = {0xFC,0xFA,0xE7,0x5C,0xC7,0x09,0x3F,0x1A,0x39,0x26,0xC2,0xAD,0x58,0xA6,0xFF,0xD1}; - ThriftHive_getSchema_result(const ThriftHive_getSchema_result&); ThriftHive_getSchema_result& operator=(const ThriftHive_getSchema_result&); ThriftHive_getSchema_result() { @@ -652,7 +583,6 @@ class ThriftHive_getSchema_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getSchema_result& obj); }; typedef struct _ThriftHive_getSchema_presult__isset { @@ -664,9 +594,6 @@ typedef struct _ThriftHive_getSchema_presult__isset { class ThriftHive_getSchema_presult { public: - static const char* ascii_fingerprint; // = "FCFAE75CC7093F1A3926C2AD58A6FFD1"; - static const uint8_t binary_fingerprint[16]; // = {0xFC,0xFA,0xE7,0x5C,0xC7,0x09,0x3F,0x1A,0x39,0x26,0xC2,0xAD,0x58,0xA6,0xFF,0xD1}; - virtual ~ThriftHive_getSchema_presult() throw(); ::Apache::Hadoop::Hive::Schema* success; @@ -676,16 +603,12 @@ class ThriftHive_getSchema_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getSchema_presult& obj); }; class ThriftHive_getThriftSchema_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_getThriftSchema_args(const ThriftHive_getThriftSchema_args&); ThriftHive_getThriftSchema_args& operator=(const ThriftHive_getThriftSchema_args&); ThriftHive_getThriftSchema_args() { @@ -706,22 +629,17 @@ class ThriftHive_getThriftSchema_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getThriftSchema_args& obj); }; class ThriftHive_getThriftSchema_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_getThriftSchema_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getThriftSchema_pargs& obj); }; typedef struct _ThriftHive_getThriftSchema_result__isset { @@ -733,9 +651,6 @@ typedef struct _ThriftHive_getThriftSchema_result__isset { class ThriftHive_getThriftSchema_result { public: - static const char* ascii_fingerprint; // = "FCFAE75CC7093F1A3926C2AD58A6FFD1"; - static const uint8_t binary_fingerprint[16]; // = {0xFC,0xFA,0xE7,0x5C,0xC7,0x09,0x3F,0x1A,0x39,0x26,0xC2,0xAD,0x58,0xA6,0xFF,0xD1}; - ThriftHive_getThriftSchema_result(const ThriftHive_getThriftSchema_result&); ThriftHive_getThriftSchema_result& operator=(const ThriftHive_getThriftSchema_result&); ThriftHive_getThriftSchema_result() { @@ -768,7 +683,6 @@ class ThriftHive_getThriftSchema_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getThriftSchema_result& obj); }; typedef struct _ThriftHive_getThriftSchema_presult__isset { @@ -780,9 +694,6 @@ typedef struct _ThriftHive_getThriftSchema_presult__isset { class ThriftHive_getThriftSchema_presult { public: - static const char* ascii_fingerprint; // = "FCFAE75CC7093F1A3926C2AD58A6FFD1"; - static const uint8_t binary_fingerprint[16]; // = {0xFC,0xFA,0xE7,0x5C,0xC7,0x09,0x3F,0x1A,0x39,0x26,0xC2,0xAD,0x58,0xA6,0xFF,0xD1}; - virtual ~ThriftHive_getThriftSchema_presult() throw(); ::Apache::Hadoop::Hive::Schema* success; @@ -792,16 +703,12 @@ class ThriftHive_getThriftSchema_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getThriftSchema_presult& obj); }; class ThriftHive_getClusterStatus_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_getClusterStatus_args(const ThriftHive_getClusterStatus_args&); ThriftHive_getClusterStatus_args& operator=(const ThriftHive_getClusterStatus_args&); ThriftHive_getClusterStatus_args() { @@ -822,22 +729,17 @@ class ThriftHive_getClusterStatus_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getClusterStatus_args& obj); }; class ThriftHive_getClusterStatus_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_getClusterStatus_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getClusterStatus_pargs& obj); }; typedef struct _ThriftHive_getClusterStatus_result__isset { @@ -849,9 +751,6 @@ typedef struct _ThriftHive_getClusterStatus_result__isset { class ThriftHive_getClusterStatus_result { public: - static const char* ascii_fingerprint; // = "F486E00F8F0F2B6A17A0371997BB7B87"; - static const uint8_t binary_fingerprint[16]; // = {0xF4,0x86,0xE0,0x0F,0x8F,0x0F,0x2B,0x6A,0x17,0xA0,0x37,0x19,0x97,0xBB,0x7B,0x87}; - ThriftHive_getClusterStatus_result(const ThriftHive_getClusterStatus_result&); ThriftHive_getClusterStatus_result& operator=(const ThriftHive_getClusterStatus_result&); ThriftHive_getClusterStatus_result() { @@ -884,7 +783,6 @@ class ThriftHive_getClusterStatus_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getClusterStatus_result& obj); }; typedef struct _ThriftHive_getClusterStatus_presult__isset { @@ -896,9 +794,6 @@ typedef struct _ThriftHive_getClusterStatus_presult__isset { class ThriftHive_getClusterStatus_presult { public: - static const char* ascii_fingerprint; // = "F486E00F8F0F2B6A17A0371997BB7B87"; - static const uint8_t binary_fingerprint[16]; // = {0xF4,0x86,0xE0,0x0F,0x8F,0x0F,0x2B,0x6A,0x17,0xA0,0x37,0x19,0x97,0xBB,0x7B,0x87}; - virtual ~ThriftHive_getClusterStatus_presult() throw(); HiveClusterStatus* success; @@ -908,16 +803,12 @@ class ThriftHive_getClusterStatus_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getClusterStatus_presult& obj); }; class ThriftHive_getQueryPlan_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_getQueryPlan_args(const ThriftHive_getQueryPlan_args&); ThriftHive_getQueryPlan_args& operator=(const ThriftHive_getQueryPlan_args&); ThriftHive_getQueryPlan_args() { @@ -938,22 +829,17 @@ class ThriftHive_getQueryPlan_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getQueryPlan_args& obj); }; class ThriftHive_getQueryPlan_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_getQueryPlan_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getQueryPlan_pargs& obj); }; typedef struct _ThriftHive_getQueryPlan_result__isset { @@ -965,9 +851,6 @@ typedef struct _ThriftHive_getQueryPlan_result__isset { class ThriftHive_getQueryPlan_result { public: - static const char* ascii_fingerprint; // = "0263544CFF7194CEE7DC6128DD5941ED"; - static const uint8_t binary_fingerprint[16]; // = {0x02,0x63,0x54,0x4C,0xFF,0x71,0x94,0xCE,0xE7,0xDC,0x61,0x28,0xDD,0x59,0x41,0xED}; - ThriftHive_getQueryPlan_result(const ThriftHive_getQueryPlan_result&); ThriftHive_getQueryPlan_result& operator=(const ThriftHive_getQueryPlan_result&); ThriftHive_getQueryPlan_result() { @@ -1000,7 +883,6 @@ class ThriftHive_getQueryPlan_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getQueryPlan_result& obj); }; typedef struct _ThriftHive_getQueryPlan_presult__isset { @@ -1012,9 +894,6 @@ typedef struct _ThriftHive_getQueryPlan_presult__isset { class ThriftHive_getQueryPlan_presult { public: - static const char* ascii_fingerprint; // = "0263544CFF7194CEE7DC6128DD5941ED"; - static const uint8_t binary_fingerprint[16]; // = {0x02,0x63,0x54,0x4C,0xFF,0x71,0x94,0xCE,0xE7,0xDC,0x61,0x28,0xDD,0x59,0x41,0xED}; - virtual ~ThriftHive_getQueryPlan_presult() throw(); ::Apache::Hadoop::Hive::QueryPlan* success; @@ -1024,16 +903,12 @@ class ThriftHive_getQueryPlan_presult { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_getQueryPlan_presult& obj); }; class ThriftHive_clean_args { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_clean_args(const ThriftHive_clean_args&); ThriftHive_clean_args& operator=(const ThriftHive_clean_args&); ThriftHive_clean_args() { @@ -1054,31 +929,23 @@ class ThriftHive_clean_args { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_clean_args& obj); }; class ThriftHive_clean_pargs { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_clean_pargs() throw(); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_clean_pargs& obj); }; class ThriftHive_clean_result { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - ThriftHive_clean_result(const ThriftHive_clean_result&); ThriftHive_clean_result& operator=(const ThriftHive_clean_result&); ThriftHive_clean_result() { @@ -1099,22 +966,17 @@ class ThriftHive_clean_result { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_clean_result& obj); }; class ThriftHive_clean_presult { public: - static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; - static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; - virtual ~ThriftHive_clean_presult() throw(); uint32_t read(::apache::thrift::protocol::TProtocol* iprot); - friend std::ostream& operator<<(std::ostream& out, const ThriftHive_clean_presult& obj); }; class ThriftHiveClient : virtual public ThriftHiveIf, public ::Apache::Hadoop::Hive::ThriftHiveMetastoreClient { @@ -1310,6 +1172,53 @@ class ThriftHiveMultiface : virtual public ThriftHiveIf, public ::Apache::Hadoo }; +// The 'concurrent' client is a thread safe client that correctly handles +// out of order responses. It is slower than the regular client, so should +// only be used when you need to share a connection among multiple threads +class ThriftHiveConcurrentClient : virtual public ThriftHiveIf, public ::Apache::Hadoop::Hive::ThriftHiveMetastoreConcurrentClient { + public: + ThriftHiveConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : + ::Apache::Hadoop::Hive::ThriftHiveMetastoreConcurrentClient(prot, prot) {} + ThriftHiveConcurrentClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::Apache::Hadoop::Hive::ThriftHiveMetastoreConcurrentClient(iprot, oprot) {} + boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { + return piprot_; + } + boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { + return poprot_; + } + void execute(const std::string& query); + int32_t send_execute(const std::string& query); + void recv_execute(const int32_t seqid); + void fetchOne(std::string& _return); + int32_t send_fetchOne(); + void recv_fetchOne(std::string& _return, const int32_t seqid); + void fetchN(std::vector<std::string> & _return, const int32_t numRows); + int32_t send_fetchN(const int32_t numRows); + void recv_fetchN(std::vector<std::string> & _return, const int32_t seqid); + void fetchAll(std::vector<std::string> & _return); + int32_t send_fetchAll(); + void recv_fetchAll(std::vector<std::string> & _return, const int32_t seqid); + void getSchema( ::Apache::Hadoop::Hive::Schema& _return); + int32_t send_getSchema(); + void recv_getSchema( ::Apache::Hadoop::Hive::Schema& _return, const int32_t seqid); + void getThriftSchema( ::Apache::Hadoop::Hive::Schema& _return); + int32_t send_getThriftSchema(); + void recv_getThriftSchema( ::Apache::Hadoop::Hive::Schema& _return, const int32_t seqid); + void getClusterStatus(HiveClusterStatus& _return); + int32_t send_getClusterStatus(); + void recv_getClusterStatus(HiveClusterStatus& _return, const int32_t seqid); + void getQueryPlan( ::Apache::Hadoop::Hive::QueryPlan& _return); + int32_t send_getQueryPlan(); + void recv_getQueryPlan( ::Apache::Hadoop::Hive::QueryPlan& _return, const int32_t seqid); + void clean(); + int32_t send_clean(); + void recv_clean(const int32_t seqid); +}; + +#ifdef _WIN32 + #pragma warning( pop ) +#endif + }}} // namespace #endif http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/hive_service_constants.cpp ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/hive_service_constants.cpp b/service/src/gen/thrift/gen-cpp/hive_service_constants.cpp index c3c8482..e2bbe71 100644 --- a/service/src/gen/thrift/gen-cpp/hive_service_constants.cpp +++ b/service/src/gen/thrift/gen-cpp/hive_service_constants.cpp @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/hive_service_constants.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/hive_service_constants.h b/service/src/gen/thrift/gen-cpp/hive_service_constants.h index 5878dbe..e0887f4 100644 --- a/service/src/gen/thrift/gen-cpp/hive_service_constants.h +++ b/service/src/gen/thrift/gen-cpp/hive_service_constants.h @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/hive_service_types.cpp ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/hive_service_types.cpp b/service/src/gen/thrift/gen-cpp/hive_service_types.cpp index 4d6cf01..9ddf7c1 100644 --- a/service/src/gen/thrift/gen-cpp/hive_service_types.cpp +++ b/service/src/gen/thrift/gen-cpp/hive_service_types.cpp @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -52,11 +52,9 @@ void HiveClusterStatus::__set_state(const JobTrackerState::type val) { this->state = val; } -const char* HiveClusterStatus::ascii_fingerprint = "D514EDCFFC86F64A2E924DCD16D4FAD8"; -const uint8_t HiveClusterStatus::binary_fingerprint[16] = {0xD5,0x14,0xED,0xCF,0xFC,0x86,0xF6,0x4A,0x2E,0x92,0x4D,0xCD,0x16,0xD4,0xFA,0xD8}; - uint32_t HiveClusterStatus::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -139,7 +137,7 @@ uint32_t HiveClusterStatus::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t HiveClusterStatus::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("HiveClusterStatus"); xfer += oprot->writeFieldBegin("taskTrackers", ::apache::thrift::protocol::T_I32, 1); @@ -168,7 +166,6 @@ uint32_t HiveClusterStatus::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -202,17 +199,16 @@ HiveClusterStatus& HiveClusterStatus::operator=(const HiveClusterStatus& other2) __isset = other2.__isset; return *this; } -std::ostream& operator<<(std::ostream& out, const HiveClusterStatus& obj) { - using apache::thrift::to_string; +void HiveClusterStatus::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; out << "HiveClusterStatus("; - out << "taskTrackers=" << to_string(obj.taskTrackers); - out << ", " << "mapTasks=" << to_string(obj.mapTasks); - out << ", " << "reduceTasks=" << to_string(obj.reduceTasks); - out << ", " << "maxMapTasks=" << to_string(obj.maxMapTasks); - out << ", " << "maxReduceTasks=" << to_string(obj.maxReduceTasks); - out << ", " << "state=" << to_string(obj.state); + out << "taskTrackers=" << to_string(taskTrackers); + out << ", " << "mapTasks=" << to_string(mapTasks); + out << ", " << "reduceTasks=" << to_string(reduceTasks); + out << ", " << "maxMapTasks=" << to_string(maxMapTasks); + out << ", " << "maxReduceTasks=" << to_string(maxReduceTasks); + out << ", " << "state=" << to_string(state); out << ")"; - return out; } @@ -232,11 +228,9 @@ void HiveServerException::__set_SQLState(const std::string& val) { this->SQLState = val; } -const char* HiveServerException::ascii_fingerprint = "70563A0628F75DF9555F4D24690B1E26"; -const uint8_t HiveServerException::binary_fingerprint[16] = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26}; - uint32_t HiveServerException::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -293,7 +287,7 @@ uint32_t HiveServerException::read(::apache::thrift::protocol::TProtocol* iprot) uint32_t HiveServerException::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - oprot->incrementRecursionDepth(); + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("HiveServerException"); xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1); @@ -310,7 +304,6 @@ uint32_t HiveServerException::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); - oprot->decrementRecursionDepth(); return xfer; } @@ -335,14 +328,24 @@ HiveServerException& HiveServerException::operator=(const HiveServerException& o __isset = other4.__isset; return *this; } -std::ostream& operator<<(std::ostream& out, const HiveServerException& obj) { - using apache::thrift::to_string; +void HiveServerException::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; out << "HiveServerException("; - out << "message=" << to_string(obj.message); - out << ", " << "errorCode=" << to_string(obj.errorCode); - out << ", " << "SQLState=" << to_string(obj.SQLState); + out << "message=" << to_string(message); + out << ", " << "errorCode=" << to_string(errorCode); + out << ", " << "SQLState=" << to_string(SQLState); out << ")"; - return out; +} + +const char* HiveServerException::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: HiveServerException"; + } } }}} // namespace http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-cpp/hive_service_types.h ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-cpp/hive_service_types.h b/service/src/gen/thrift/gen-cpp/hive_service_types.h index 7fea88c..266f8ea 100644 --- a/service/src/gen/thrift/gen-cpp/hive_service_types.h +++ b/service/src/gen/thrift/gen-cpp/hive_service_types.h @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -48,9 +48,6 @@ typedef struct _HiveClusterStatus__isset { class HiveClusterStatus { public: - static const char* ascii_fingerprint; // = "D514EDCFFC86F64A2E924DCD16D4FAD8"; - static const uint8_t binary_fingerprint[16]; // = {0xD5,0x14,0xED,0xCF,0xFC,0x86,0xF6,0x4A,0x2E,0x92,0x4D,0xCD,0x16,0xD4,0xFA,0xD8}; - HiveClusterStatus(const HiveClusterStatus&); HiveClusterStatus& operator=(const HiveClusterStatus&); HiveClusterStatus() : taskTrackers(0), mapTasks(0), reduceTasks(0), maxMapTasks(0), maxReduceTasks(0), state((JobTrackerState::type)0) { @@ -103,11 +100,17 @@ class HiveClusterStatus { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const HiveClusterStatus& obj); + virtual void printTo(std::ostream& out) const; }; void swap(HiveClusterStatus &a, HiveClusterStatus &b); +inline std::ostream& operator<<(std::ostream& out, const HiveClusterStatus& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _HiveServerException__isset { _HiveServerException__isset() : message(false), errorCode(false), SQLState(false) {} bool message :1; @@ -118,9 +121,6 @@ typedef struct _HiveServerException__isset { class HiveServerException : public ::apache::thrift::TException { public: - static const char* ascii_fingerprint; // = "70563A0628F75DF9555F4D24690B1E26"; - static const uint8_t binary_fingerprint[16]; // = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26}; - HiveServerException(const HiveServerException&); HiveServerException& operator=(const HiveServerException&); HiveServerException() : message(), errorCode(0), SQLState() { @@ -158,11 +158,19 @@ class HiveServerException : public ::apache::thrift::TException { uint32_t read(::apache::thrift::protocol::TProtocol* iprot); uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; - friend std::ostream& operator<<(std::ostream& out, const HiveServerException& obj); + virtual void printTo(std::ostream& out) const; + mutable std::string thriftTExceptionMessageHolder_; + const char* what() const throw(); }; void swap(HiveServerException &a, HiveServerException &b); +inline std::ostream& operator<<(std::ostream& out, const HiveServerException& obj) +{ + obj.printTo(out); + return out; +} + }}} // namespace #endif http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveClusterStatus.java ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveClusterStatus.java b/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveClusterStatus.java index 028829d..ad89867 100644 --- a/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveClusterStatus.java +++ b/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveClusterStatus.java @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -34,7 +34,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-10-21") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") public class HiveClusterStatus implements org.apache.thrift.TBase<HiveClusterStatus, HiveClusterStatus._Fields>, java.io.Serializable, Cloneable, Comparable<HiveClusterStatus> { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("HiveClusterStatus"); @@ -417,19 +417,19 @@ public class HiveClusterStatus implements org.apache.thrift.TBase<HiveClusterSta public Object getFieldValue(_Fields field) { switch (field) { case TASK_TRACKERS: - return Integer.valueOf(getTaskTrackers()); + return getTaskTrackers(); case MAP_TASKS: - return Integer.valueOf(getMapTasks()); + return getMapTasks(); case REDUCE_TASKS: - return Integer.valueOf(getReduceTasks()); + return getReduceTasks(); case MAX_MAP_TASKS: - return Integer.valueOf(getMaxMapTasks()); + return getMaxMapTasks(); case MAX_REDUCE_TASKS: - return Integer.valueOf(getMaxReduceTasks()); + return getMaxReduceTasks(); case STATE: return getState(); http://git-wip-us.apache.org/repos/asf/hive/blob/26535378/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveServerException.java ---------------------------------------------------------------------- diff --git a/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveServerException.java b/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveServerException.java index 45f21f9..97b1219 100644 --- a/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveServerException.java +++ b/service/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/service/HiveServerException.java @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.2) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -34,7 +34,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; @SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) -@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-10-21") +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") public class HiveServerException extends TException implements org.apache.thrift.TBase<HiveServerException, HiveServerException._Fields>, java.io.Serializable, Cloneable, Comparable<HiveServerException> { private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("HiveServerException"); @@ -276,7 +276,7 @@ public class HiveServerException extends TException implements org.apache.thrift return getMessage(); case ERROR_CODE: - return Integer.valueOf(getErrorCode()); + return getErrorCode(); case SQLSTATE: return getSQLState();