hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ga...@apache.org
Subject [04/22] hive git commit: HIVE-12832 Thrift and RDBMS schema changes for ACID fixes, branch-1 version.
Date Fri, 15 Jan 2016 01:17:53 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/92072ad2/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/92072ad2/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/92072ad2/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/92072ad2/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/92072ad2/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/92072ad2/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/92072ad2/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 d4b6972..e7651e0 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-8-3")
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2016-01-14")
 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/92072ad2/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 760c81e..14becd1 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-8-3")
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2016-01-14")
 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();


Mime
View raw message