hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From xu...@apache.org
Subject [26/54] [abbrv] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)
Date Fri, 31 Jul 2015 22:57:27 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp b/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp
index 19d4806..a1fb60b 100644
--- a/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp
+++ b/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,6 +7,9 @@
 #include "queryplan_types.h"
 
 #include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
 
 namespace Apache { namespace Hadoop { namespace Hive {
 
@@ -55,7 +58,8 @@ int _kOperatorTypeValues[] = {
   OperatorType::EVENT,
   OperatorType::ORCFILEMERGE,
   OperatorType::RCFILEMERGE,
-  OperatorType::MERGEJOIN
+  OperatorType::MERGEJOIN,
+  OperatorType::SPARKPRUNINGSINK
 };
 const char* _kOperatorTypeNames[] = {
   "JOIN",
@@ -82,9 +86,10 @@ const char* _kOperatorTypeNames[] = {
   "EVENT",
   "ORCFILEMERGE",
   "RCFILEMERGE",
-  "MERGEJOIN"
+  "MERGEJOIN",
+  "SPARKPRUNINGSINK"
 };
-const std::map<int, const char*> _OperatorType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(25, _kOperatorTypeValues, _kOperatorTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+const std::map<int, const char*> _OperatorType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(26, _kOperatorTypeValues, _kOperatorTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
 int _kTaskTypeValues[] = {
   TaskType::MAP,
@@ -128,6 +133,23 @@ const char* _kStageTypeNames[] = {
 };
 const std::map<int, const char*> _StageType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(12, _kStageTypeValues, _kStageTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
+
+Adjacency::~Adjacency() throw() {
+}
+
+
+void Adjacency::__set_node(const std::string& val) {
+  this->node = val;
+}
+
+void Adjacency::__set_children(const std::vector<std::string> & val) {
+  this->children = val;
+}
+
+void Adjacency::__set_adjacencyType(const AdjacencyType::type val) {
+  this->adjacencyType = val;
+}
+
 const char* Adjacency::ascii_fingerprint = "BC4F8C394677A1003AA9F56ED26D8204";
 const uint8_t Adjacency::binary_fingerprint[16] = {0xBC,0x4F,0x8C,0x39,0x46,0x77,0xA1,0x00,0x3A,0xA9,0xF5,0x6E,0xD2,0x6D,0x82,0x04};
 
@@ -203,6 +225,7 @@ uint32_t Adjacency::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Adjacency::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Adjacency");
 
   xfer += oprot->writeFieldBegin("node", ::apache::thrift::protocol::T_STRING, 1);
@@ -227,6 +250,7 @@ uint32_t Adjacency::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -238,6 +262,46 @@ void swap(Adjacency &a, Adjacency &b) {
   swap(a.__isset, b.__isset);
 }
 
+Adjacency::Adjacency(const Adjacency& other7) {
+  node = other7.node;
+  children = other7.children;
+  adjacencyType = other7.adjacencyType;
+  __isset = other7.__isset;
+}
+Adjacency& Adjacency::operator=(const Adjacency& other8) {
+  node = other8.node;
+  children = other8.children;
+  adjacencyType = other8.adjacencyType;
+  __isset = other8.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Adjacency& obj) {
+  using apache::thrift::to_string;
+  out << "Adjacency(";
+  out << "node=" << to_string(obj.node);
+  out << ", " << "children=" << to_string(obj.children);
+  out << ", " << "adjacencyType=" << to_string(obj.adjacencyType);
+  out << ")";
+  return out;
+}
+
+
+Graph::~Graph() throw() {
+}
+
+
+void Graph::__set_nodeType(const NodeType::type val) {
+  this->nodeType = val;
+}
+
+void Graph::__set_roots(const std::vector<std::string> & val) {
+  this->roots = val;
+}
+
+void Graph::__set_adjacencyList(const std::vector<Adjacency> & val) {
+  this->adjacencyList = val;
+}
+
 const char* Graph::ascii_fingerprint = "1F7FB604B3EF8F7AFB5DEAD15F2FC0B5";
 const uint8_t Graph::binary_fingerprint[16] = {0x1F,0x7F,0xB6,0x04,0xB3,0xEF,0x8F,0x7A,0xFB,0x5D,0xEA,0xD1,0x5F,0x2F,0xC0,0xB5};
 
@@ -263,9 +327,9 @@ uint32_t Graph::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast7;
-          xfer += iprot->readI32(ecast7);
-          this->nodeType = (NodeType::type)ecast7;
+          int32_t ecast9;
+          xfer += iprot->readI32(ecast9);
+          this->nodeType = (NodeType::type)ecast9;
           this->__isset.nodeType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -275,14 +339,14 @@ uint32_t Graph::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->roots.clear();
-            uint32_t _size8;
-            ::apache::thrift::protocol::TType _etype11;
-            xfer += iprot->readListBegin(_etype11, _size8);
-            this->roots.resize(_size8);
-            uint32_t _i12;
-            for (_i12 = 0; _i12 < _size8; ++_i12)
+            uint32_t _size10;
+            ::apache::thrift::protocol::TType _etype13;
+            xfer += iprot->readListBegin(_etype13, _size10);
+            this->roots.resize(_size10);
+            uint32_t _i14;
+            for (_i14 = 0; _i14 < _size10; ++_i14)
             {
-              xfer += iprot->readString(this->roots[_i12]);
+              xfer += iprot->readString(this->roots[_i14]);
             }
             xfer += iprot->readListEnd();
           }
@@ -295,14 +359,14 @@ uint32_t Graph::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->adjacencyList.clear();
-            uint32_t _size13;
-            ::apache::thrift::protocol::TType _etype16;
-            xfer += iprot->readListBegin(_etype16, _size13);
-            this->adjacencyList.resize(_size13);
-            uint32_t _i17;
-            for (_i17 = 0; _i17 < _size13; ++_i17)
+            uint32_t _size15;
+            ::apache::thrift::protocol::TType _etype18;
+            xfer += iprot->readListBegin(_etype18, _size15);
+            this->adjacencyList.resize(_size15);
+            uint32_t _i19;
+            for (_i19 = 0; _i19 < _size15; ++_i19)
             {
-              xfer += this->adjacencyList[_i17].read(iprot);
+              xfer += this->adjacencyList[_i19].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -325,6 +389,7 @@ uint32_t Graph::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Graph::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Graph");
 
   xfer += oprot->writeFieldBegin("nodeType", ::apache::thrift::protocol::T_I32, 1);
@@ -334,10 +399,10 @@ uint32_t Graph::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("roots", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->roots.size()));
-    std::vector<std::string> ::const_iterator _iter18;
-    for (_iter18 = this->roots.begin(); _iter18 != this->roots.end(); ++_iter18)
+    std::vector<std::string> ::const_iterator _iter20;
+    for (_iter20 = this->roots.begin(); _iter20 != this->roots.end(); ++_iter20)
     {
-      xfer += oprot->writeString((*_iter18));
+      xfer += oprot->writeString((*_iter20));
     }
     xfer += oprot->writeListEnd();
   }
@@ -346,10 +411,10 @@ uint32_t Graph::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("adjacencyList", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->adjacencyList.size()));
-    std::vector<Adjacency> ::const_iterator _iter19;
-    for (_iter19 = this->adjacencyList.begin(); _iter19 != this->adjacencyList.end(); ++_iter19)
+    std::vector<Adjacency> ::const_iterator _iter21;
+    for (_iter21 = this->adjacencyList.begin(); _iter21 != this->adjacencyList.end(); ++_iter21)
     {
-      xfer += (*_iter19).write(oprot);
+      xfer += (*_iter21).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -357,6 +422,7 @@ uint32_t Graph::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -368,6 +434,58 @@ void swap(Graph &a, Graph &b) {
   swap(a.__isset, b.__isset);
 }
 
+Graph::Graph(const Graph& other22) {
+  nodeType = other22.nodeType;
+  roots = other22.roots;
+  adjacencyList = other22.adjacencyList;
+  __isset = other22.__isset;
+}
+Graph& Graph::operator=(const Graph& other23) {
+  nodeType = other23.nodeType;
+  roots = other23.roots;
+  adjacencyList = other23.adjacencyList;
+  __isset = other23.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Graph& obj) {
+  using apache::thrift::to_string;
+  out << "Graph(";
+  out << "nodeType=" << to_string(obj.nodeType);
+  out << ", " << "roots=" << to_string(obj.roots);
+  out << ", " << "adjacencyList=" << to_string(obj.adjacencyList);
+  out << ")";
+  return out;
+}
+
+
+Operator::~Operator() throw() {
+}
+
+
+void Operator::__set_operatorId(const std::string& val) {
+  this->operatorId = val;
+}
+
+void Operator::__set_operatorType(const OperatorType::type val) {
+  this->operatorType = val;
+}
+
+void Operator::__set_operatorAttributes(const std::map<std::string, std::string> & val) {
+  this->operatorAttributes = val;
+}
+
+void Operator::__set_operatorCounters(const std::map<std::string, int64_t> & val) {
+  this->operatorCounters = val;
+}
+
+void Operator::__set_done(const bool val) {
+  this->done = val;
+}
+
+void Operator::__set_started(const bool val) {
+  this->started = val;
+}
+
 const char* Operator::ascii_fingerprint = "30917C758A752485AF223B697479DE6C";
 const uint8_t Operator::binary_fingerprint[16] = {0x30,0x91,0x7C,0x75,0x8A,0x75,0x24,0x85,0xAF,0x22,0x3B,0x69,0x74,0x79,0xDE,0x6C};
 
@@ -401,9 +519,9 @@ uint32_t Operator::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast20;
-          xfer += iprot->readI32(ecast20);
-          this->operatorType = (OperatorType::type)ecast20;
+          int32_t ecast24;
+          xfer += iprot->readI32(ecast24);
+          this->operatorType = (OperatorType::type)ecast24;
           this->__isset.operatorType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -413,17 +531,17 @@ uint32_t Operator::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->operatorAttributes.clear();
-            uint32_t _size21;
-            ::apache::thrift::protocol::TType _ktype22;
-            ::apache::thrift::protocol::TType _vtype23;
-            xfer += iprot->readMapBegin(_ktype22, _vtype23, _size21);
-            uint32_t _i25;
-            for (_i25 = 0; _i25 < _size21; ++_i25)
+            uint32_t _size25;
+            ::apache::thrift::protocol::TType _ktype26;
+            ::apache::thrift::protocol::TType _vtype27;
+            xfer += iprot->readMapBegin(_ktype26, _vtype27, _size25);
+            uint32_t _i29;
+            for (_i29 = 0; _i29 < _size25; ++_i29)
             {
-              std::string _key26;
-              xfer += iprot->readString(_key26);
-              std::string& _val27 = this->operatorAttributes[_key26];
-              xfer += iprot->readString(_val27);
+              std::string _key30;
+              xfer += iprot->readString(_key30);
+              std::string& _val31 = this->operatorAttributes[_key30];
+              xfer += iprot->readString(_val31);
             }
             xfer += iprot->readMapEnd();
           }
@@ -436,17 +554,17 @@ uint32_t Operator::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->operatorCounters.clear();
-            uint32_t _size28;
-            ::apache::thrift::protocol::TType _ktype29;
-            ::apache::thrift::protocol::TType _vtype30;
-            xfer += iprot->readMapBegin(_ktype29, _vtype30, _size28);
-            uint32_t _i32;
-            for (_i32 = 0; _i32 < _size28; ++_i32)
+            uint32_t _size32;
+            ::apache::thrift::protocol::TType _ktype33;
+            ::apache::thrift::protocol::TType _vtype34;
+            xfer += iprot->readMapBegin(_ktype33, _vtype34, _size32);
+            uint32_t _i36;
+            for (_i36 = 0; _i36 < _size32; ++_i36)
             {
-              std::string _key33;
-              xfer += iprot->readString(_key33);
-              int64_t& _val34 = this->operatorCounters[_key33];
-              xfer += iprot->readI64(_val34);
+              std::string _key37;
+              xfer += iprot->readString(_key37);
+              int64_t& _val38 = this->operatorCounters[_key37];
+              xfer += iprot->readI64(_val38);
             }
             xfer += iprot->readMapEnd();
           }
@@ -485,6 +603,7 @@ uint32_t Operator::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Operator::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Operator");
 
   xfer += oprot->writeFieldBegin("operatorId", ::apache::thrift::protocol::T_STRING, 1);
@@ -498,11 +617,11 @@ uint32_t Operator::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("operatorAttributes", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->operatorAttributes.size()));
-    std::map<std::string, std::string> ::const_iterator _iter35;
-    for (_iter35 = this->operatorAttributes.begin(); _iter35 != this->operatorAttributes.end(); ++_iter35)
+    std::map<std::string, std::string> ::const_iterator _iter39;
+    for (_iter39 = this->operatorAttributes.begin(); _iter39 != this->operatorAttributes.end(); ++_iter39)
     {
-      xfer += oprot->writeString(_iter35->first);
-      xfer += oprot->writeString(_iter35->second);
+      xfer += oprot->writeString(_iter39->first);
+      xfer += oprot->writeString(_iter39->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -511,11 +630,11 @@ uint32_t Operator::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("operatorCounters", ::apache::thrift::protocol::T_MAP, 4);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->operatorCounters.size()));
-    std::map<std::string, int64_t> ::const_iterator _iter36;
-    for (_iter36 = this->operatorCounters.begin(); _iter36 != this->operatorCounters.end(); ++_iter36)
+    std::map<std::string, int64_t> ::const_iterator _iter40;
+    for (_iter40 = this->operatorCounters.begin(); _iter40 != this->operatorCounters.end(); ++_iter40)
     {
-      xfer += oprot->writeString(_iter36->first);
-      xfer += oprot->writeI64(_iter36->second);
+      xfer += oprot->writeString(_iter40->first);
+      xfer += oprot->writeI64(_iter40->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -531,6 +650,7 @@ uint32_t Operator::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -545,6 +665,77 @@ void swap(Operator &a, Operator &b) {
   swap(a.__isset, b.__isset);
 }
 
+Operator::Operator(const Operator& other41) {
+  operatorId = other41.operatorId;
+  operatorType = other41.operatorType;
+  operatorAttributes = other41.operatorAttributes;
+  operatorCounters = other41.operatorCounters;
+  done = other41.done;
+  started = other41.started;
+  __isset = other41.__isset;
+}
+Operator& Operator::operator=(const Operator& other42) {
+  operatorId = other42.operatorId;
+  operatorType = other42.operatorType;
+  operatorAttributes = other42.operatorAttributes;
+  operatorCounters = other42.operatorCounters;
+  done = other42.done;
+  started = other42.started;
+  __isset = other42.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Operator& obj) {
+  using apache::thrift::to_string;
+  out << "Operator(";
+  out << "operatorId=" << to_string(obj.operatorId);
+  out << ", " << "operatorType=" << to_string(obj.operatorType);
+  out << ", " << "operatorAttributes=" << to_string(obj.operatorAttributes);
+  out << ", " << "operatorCounters=" << to_string(obj.operatorCounters);
+  out << ", " << "done=" << to_string(obj.done);
+  out << ", " << "started=" << to_string(obj.started);
+  out << ")";
+  return out;
+}
+
+
+Task::~Task() throw() {
+}
+
+
+void Task::__set_taskId(const std::string& val) {
+  this->taskId = val;
+}
+
+void Task::__set_taskType(const TaskType::type val) {
+  this->taskType = val;
+}
+
+void Task::__set_taskAttributes(const std::map<std::string, std::string> & val) {
+  this->taskAttributes = val;
+}
+
+void Task::__set_taskCounters(const std::map<std::string, int64_t> & val) {
+  this->taskCounters = val;
+}
+
+void Task::__set_operatorGraph(const Graph& val) {
+  this->operatorGraph = val;
+__isset.operatorGraph = true;
+}
+
+void Task::__set_operatorList(const std::vector<Operator> & val) {
+  this->operatorList = val;
+__isset.operatorList = true;
+}
+
+void Task::__set_done(const bool val) {
+  this->done = val;
+}
+
+void Task::__set_started(const bool val) {
+  this->started = val;
+}
+
 const char* Task::ascii_fingerprint = "AC741A136EFA51843AFC3A12F6A793D1";
 const uint8_t Task::binary_fingerprint[16] = {0xAC,0x74,0x1A,0x13,0x6E,0xFA,0x51,0x84,0x3A,0xFC,0x3A,0x12,0xF6,0xA7,0x93,0xD1};
 
@@ -578,9 +769,9 @@ uint32_t Task::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast37;
-          xfer += iprot->readI32(ecast37);
-          this->taskType = (TaskType::type)ecast37;
+          int32_t ecast43;
+          xfer += iprot->readI32(ecast43);
+          this->taskType = (TaskType::type)ecast43;
           this->__isset.taskType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -590,17 +781,17 @@ uint32_t Task::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->taskAttributes.clear();
-            uint32_t _size38;
-            ::apache::thrift::protocol::TType _ktype39;
-            ::apache::thrift::protocol::TType _vtype40;
-            xfer += iprot->readMapBegin(_ktype39, _vtype40, _size38);
-            uint32_t _i42;
-            for (_i42 = 0; _i42 < _size38; ++_i42)
+            uint32_t _size44;
+            ::apache::thrift::protocol::TType _ktype45;
+            ::apache::thrift::protocol::TType _vtype46;
+            xfer += iprot->readMapBegin(_ktype45, _vtype46, _size44);
+            uint32_t _i48;
+            for (_i48 = 0; _i48 < _size44; ++_i48)
             {
-              std::string _key43;
-              xfer += iprot->readString(_key43);
-              std::string& _val44 = this->taskAttributes[_key43];
-              xfer += iprot->readString(_val44);
+              std::string _key49;
+              xfer += iprot->readString(_key49);
+              std::string& _val50 = this->taskAttributes[_key49];
+              xfer += iprot->readString(_val50);
             }
             xfer += iprot->readMapEnd();
           }
@@ -613,17 +804,17 @@ uint32_t Task::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->taskCounters.clear();
-            uint32_t _size45;
-            ::apache::thrift::protocol::TType _ktype46;
-            ::apache::thrift::protocol::TType _vtype47;
-            xfer += iprot->readMapBegin(_ktype46, _vtype47, _size45);
-            uint32_t _i49;
-            for (_i49 = 0; _i49 < _size45; ++_i49)
+            uint32_t _size51;
+            ::apache::thrift::protocol::TType _ktype52;
+            ::apache::thrift::protocol::TType _vtype53;
+            xfer += iprot->readMapBegin(_ktype52, _vtype53, _size51);
+            uint32_t _i55;
+            for (_i55 = 0; _i55 < _size51; ++_i55)
             {
-              std::string _key50;
-              xfer += iprot->readString(_key50);
-              int64_t& _val51 = this->taskCounters[_key50];
-              xfer += iprot->readI64(_val51);
+              std::string _key56;
+              xfer += iprot->readString(_key56);
+              int64_t& _val57 = this->taskCounters[_key56];
+              xfer += iprot->readI64(_val57);
             }
             xfer += iprot->readMapEnd();
           }
@@ -644,14 +835,14 @@ uint32_t Task::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->operatorList.clear();
-            uint32_t _size52;
-            ::apache::thrift::protocol::TType _etype55;
-            xfer += iprot->readListBegin(_etype55, _size52);
-            this->operatorList.resize(_size52);
-            uint32_t _i56;
-            for (_i56 = 0; _i56 < _size52; ++_i56)
+            uint32_t _size58;
+            ::apache::thrift::protocol::TType _etype61;
+            xfer += iprot->readListBegin(_etype61, _size58);
+            this->operatorList.resize(_size58);
+            uint32_t _i62;
+            for (_i62 = 0; _i62 < _size58; ++_i62)
             {
-              xfer += this->operatorList[_i56].read(iprot);
+              xfer += this->operatorList[_i62].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -690,6 +881,7 @@ uint32_t Task::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Task");
 
   xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1);
@@ -703,11 +895,11 @@ uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("taskAttributes", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->taskAttributes.size()));
-    std::map<std::string, std::string> ::const_iterator _iter57;
-    for (_iter57 = this->taskAttributes.begin(); _iter57 != this->taskAttributes.end(); ++_iter57)
+    std::map<std::string, std::string> ::const_iterator _iter63;
+    for (_iter63 = this->taskAttributes.begin(); _iter63 != this->taskAttributes.end(); ++_iter63)
     {
-      xfer += oprot->writeString(_iter57->first);
-      xfer += oprot->writeString(_iter57->second);
+      xfer += oprot->writeString(_iter63->first);
+      xfer += oprot->writeString(_iter63->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -716,11 +908,11 @@ uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("taskCounters", ::apache::thrift::protocol::T_MAP, 4);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->taskCounters.size()));
-    std::map<std::string, int64_t> ::const_iterator _iter58;
-    for (_iter58 = this->taskCounters.begin(); _iter58 != this->taskCounters.end(); ++_iter58)
+    std::map<std::string, int64_t> ::const_iterator _iter64;
+    for (_iter64 = this->taskCounters.begin(); _iter64 != this->taskCounters.end(); ++_iter64)
     {
-      xfer += oprot->writeString(_iter58->first);
-      xfer += oprot->writeI64(_iter58->second);
+      xfer += oprot->writeString(_iter64->first);
+      xfer += oprot->writeI64(_iter64->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -735,10 +927,10 @@ uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("operatorList", ::apache::thrift::protocol::T_LIST, 6);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->operatorList.size()));
-      std::vector<Operator> ::const_iterator _iter59;
-      for (_iter59 = this->operatorList.begin(); _iter59 != this->operatorList.end(); ++_iter59)
+      std::vector<Operator> ::const_iterator _iter65;
+      for (_iter65 = this->operatorList.begin(); _iter65 != this->operatorList.end(); ++_iter65)
       {
-        xfer += (*_iter59).write(oprot);
+        xfer += (*_iter65).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -754,6 +946,7 @@ uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -770,6 +963,77 @@ void swap(Task &a, Task &b) {
   swap(a.__isset, b.__isset);
 }
 
+Task::Task(const Task& other66) {
+  taskId = other66.taskId;
+  taskType = other66.taskType;
+  taskAttributes = other66.taskAttributes;
+  taskCounters = other66.taskCounters;
+  operatorGraph = other66.operatorGraph;
+  operatorList = other66.operatorList;
+  done = other66.done;
+  started = other66.started;
+  __isset = other66.__isset;
+}
+Task& Task::operator=(const Task& other67) {
+  taskId = other67.taskId;
+  taskType = other67.taskType;
+  taskAttributes = other67.taskAttributes;
+  taskCounters = other67.taskCounters;
+  operatorGraph = other67.operatorGraph;
+  operatorList = other67.operatorList;
+  done = other67.done;
+  started = other67.started;
+  __isset = other67.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Task& obj) {
+  using apache::thrift::to_string;
+  out << "Task(";
+  out << "taskId=" << to_string(obj.taskId);
+  out << ", " << "taskType=" << to_string(obj.taskType);
+  out << ", " << "taskAttributes=" << to_string(obj.taskAttributes);
+  out << ", " << "taskCounters=" << to_string(obj.taskCounters);
+  out << ", " << "operatorGraph="; (obj.__isset.operatorGraph ? (out << to_string(obj.operatorGraph)) : (out << "<null>"));
+  out << ", " << "operatorList="; (obj.__isset.operatorList ? (out << to_string(obj.operatorList)) : (out << "<null>"));
+  out << ", " << "done=" << to_string(obj.done);
+  out << ", " << "started=" << to_string(obj.started);
+  out << ")";
+  return out;
+}
+
+
+Stage::~Stage() throw() {
+}
+
+
+void Stage::__set_stageId(const std::string& val) {
+  this->stageId = val;
+}
+
+void Stage::__set_stageType(const StageType::type val) {
+  this->stageType = val;
+}
+
+void Stage::__set_stageAttributes(const std::map<std::string, std::string> & val) {
+  this->stageAttributes = val;
+}
+
+void Stage::__set_stageCounters(const std::map<std::string, int64_t> & val) {
+  this->stageCounters = val;
+}
+
+void Stage::__set_taskList(const std::vector<Task> & val) {
+  this->taskList = val;
+}
+
+void Stage::__set_done(const bool val) {
+  this->done = val;
+}
+
+void Stage::__set_started(const bool val) {
+  this->started = val;
+}
+
 const char* Stage::ascii_fingerprint = "86EA3C7B0690AFED21A3D479E2B32378";
 const uint8_t Stage::binary_fingerprint[16] = {0x86,0xEA,0x3C,0x7B,0x06,0x90,0xAF,0xED,0x21,0xA3,0xD4,0x79,0xE2,0xB3,0x23,0x78};
 
@@ -803,9 +1067,9 @@ uint32_t Stage::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast60;
-          xfer += iprot->readI32(ecast60);
-          this->stageType = (StageType::type)ecast60;
+          int32_t ecast68;
+          xfer += iprot->readI32(ecast68);
+          this->stageType = (StageType::type)ecast68;
           this->__isset.stageType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -815,17 +1079,17 @@ uint32_t Stage::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->stageAttributes.clear();
-            uint32_t _size61;
-            ::apache::thrift::protocol::TType _ktype62;
-            ::apache::thrift::protocol::TType _vtype63;
-            xfer += iprot->readMapBegin(_ktype62, _vtype63, _size61);
-            uint32_t _i65;
-            for (_i65 = 0; _i65 < _size61; ++_i65)
+            uint32_t _size69;
+            ::apache::thrift::protocol::TType _ktype70;
+            ::apache::thrift::protocol::TType _vtype71;
+            xfer += iprot->readMapBegin(_ktype70, _vtype71, _size69);
+            uint32_t _i73;
+            for (_i73 = 0; _i73 < _size69; ++_i73)
             {
-              std::string _key66;
-              xfer += iprot->readString(_key66);
-              std::string& _val67 = this->stageAttributes[_key66];
-              xfer += iprot->readString(_val67);
+              std::string _key74;
+              xfer += iprot->readString(_key74);
+              std::string& _val75 = this->stageAttributes[_key74];
+              xfer += iprot->readString(_val75);
             }
             xfer += iprot->readMapEnd();
           }
@@ -838,17 +1102,17 @@ uint32_t Stage::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->stageCounters.clear();
-            uint32_t _size68;
-            ::apache::thrift::protocol::TType _ktype69;
-            ::apache::thrift::protocol::TType _vtype70;
-            xfer += iprot->readMapBegin(_ktype69, _vtype70, _size68);
-            uint32_t _i72;
-            for (_i72 = 0; _i72 < _size68; ++_i72)
+            uint32_t _size76;
+            ::apache::thrift::protocol::TType _ktype77;
+            ::apache::thrift::protocol::TType _vtype78;
+            xfer += iprot->readMapBegin(_ktype77, _vtype78, _size76);
+            uint32_t _i80;
+            for (_i80 = 0; _i80 < _size76; ++_i80)
             {
-              std::string _key73;
-              xfer += iprot->readString(_key73);
-              int64_t& _val74 = this->stageCounters[_key73];
-              xfer += iprot->readI64(_val74);
+              std::string _key81;
+              xfer += iprot->readString(_key81);
+              int64_t& _val82 = this->stageCounters[_key81];
+              xfer += iprot->readI64(_val82);
             }
             xfer += iprot->readMapEnd();
           }
@@ -861,14 +1125,14 @@ uint32_t Stage::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->taskList.clear();
-            uint32_t _size75;
-            ::apache::thrift::protocol::TType _etype78;
-            xfer += iprot->readListBegin(_etype78, _size75);
-            this->taskList.resize(_size75);
-            uint32_t _i79;
-            for (_i79 = 0; _i79 < _size75; ++_i79)
+            uint32_t _size83;
+            ::apache::thrift::protocol::TType _etype86;
+            xfer += iprot->readListBegin(_etype86, _size83);
+            this->taskList.resize(_size83);
+            uint32_t _i87;
+            for (_i87 = 0; _i87 < _size83; ++_i87)
             {
-              xfer += this->taskList[_i79].read(iprot);
+              xfer += this->taskList[_i87].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -907,6 +1171,7 @@ uint32_t Stage::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Stage");
 
   xfer += oprot->writeFieldBegin("stageId", ::apache::thrift::protocol::T_STRING, 1);
@@ -920,11 +1185,11 @@ uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("stageAttributes", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->stageAttributes.size()));
-    std::map<std::string, std::string> ::const_iterator _iter80;
-    for (_iter80 = this->stageAttributes.begin(); _iter80 != this->stageAttributes.end(); ++_iter80)
+    std::map<std::string, std::string> ::const_iterator _iter88;
+    for (_iter88 = this->stageAttributes.begin(); _iter88 != this->stageAttributes.end(); ++_iter88)
     {
-      xfer += oprot->writeString(_iter80->first);
-      xfer += oprot->writeString(_iter80->second);
+      xfer += oprot->writeString(_iter88->first);
+      xfer += oprot->writeString(_iter88->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -933,11 +1198,11 @@ uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("stageCounters", ::apache::thrift::protocol::T_MAP, 4);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->stageCounters.size()));
-    std::map<std::string, int64_t> ::const_iterator _iter81;
-    for (_iter81 = this->stageCounters.begin(); _iter81 != this->stageCounters.end(); ++_iter81)
+    std::map<std::string, int64_t> ::const_iterator _iter89;
+    for (_iter89 = this->stageCounters.begin(); _iter89 != this->stageCounters.end(); ++_iter89)
     {
-      xfer += oprot->writeString(_iter81->first);
-      xfer += oprot->writeI64(_iter81->second);
+      xfer += oprot->writeString(_iter89->first);
+      xfer += oprot->writeI64(_iter89->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -946,10 +1211,10 @@ uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("taskList", ::apache::thrift::protocol::T_LIST, 5);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->taskList.size()));
-    std::vector<Task> ::const_iterator _iter82;
-    for (_iter82 = this->taskList.begin(); _iter82 != this->taskList.end(); ++_iter82)
+    std::vector<Task> ::const_iterator _iter90;
+    for (_iter90 = this->taskList.begin(); _iter90 != this->taskList.end(); ++_iter90)
     {
-      xfer += (*_iter82).write(oprot);
+      xfer += (*_iter90).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -965,6 +1230,7 @@ uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -980,6 +1246,78 @@ void swap(Stage &a, Stage &b) {
   swap(a.__isset, b.__isset);
 }
 
+Stage::Stage(const Stage& other91) {
+  stageId = other91.stageId;
+  stageType = other91.stageType;
+  stageAttributes = other91.stageAttributes;
+  stageCounters = other91.stageCounters;
+  taskList = other91.taskList;
+  done = other91.done;
+  started = other91.started;
+  __isset = other91.__isset;
+}
+Stage& Stage::operator=(const Stage& other92) {
+  stageId = other92.stageId;
+  stageType = other92.stageType;
+  stageAttributes = other92.stageAttributes;
+  stageCounters = other92.stageCounters;
+  taskList = other92.taskList;
+  done = other92.done;
+  started = other92.started;
+  __isset = other92.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Stage& obj) {
+  using apache::thrift::to_string;
+  out << "Stage(";
+  out << "stageId=" << to_string(obj.stageId);
+  out << ", " << "stageType=" << to_string(obj.stageType);
+  out << ", " << "stageAttributes=" << to_string(obj.stageAttributes);
+  out << ", " << "stageCounters=" << to_string(obj.stageCounters);
+  out << ", " << "taskList=" << to_string(obj.taskList);
+  out << ", " << "done=" << to_string(obj.done);
+  out << ", " << "started=" << to_string(obj.started);
+  out << ")";
+  return out;
+}
+
+
+Query::~Query() throw() {
+}
+
+
+void Query::__set_queryId(const std::string& val) {
+  this->queryId = val;
+}
+
+void Query::__set_queryType(const std::string& val) {
+  this->queryType = val;
+}
+
+void Query::__set_queryAttributes(const std::map<std::string, std::string> & val) {
+  this->queryAttributes = val;
+}
+
+void Query::__set_queryCounters(const std::map<std::string, int64_t> & val) {
+  this->queryCounters = val;
+}
+
+void Query::__set_stageGraph(const Graph& val) {
+  this->stageGraph = val;
+}
+
+void Query::__set_stageList(const std::vector<Stage> & val) {
+  this->stageList = val;
+}
+
+void Query::__set_done(const bool val) {
+  this->done = val;
+}
+
+void Query::__set_started(const bool val) {
+  this->started = val;
+}
+
 const char* Query::ascii_fingerprint = "68300D63A5D40F2D17B9A9440FF626C1";
 const uint8_t Query::binary_fingerprint[16] = {0x68,0x30,0x0D,0x63,0xA5,0xD4,0x0F,0x2D,0x17,0xB9,0xA9,0x44,0x0F,0xF6,0x26,0xC1};
 
@@ -1023,17 +1361,17 @@ uint32_t Query::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->queryAttributes.clear();
-            uint32_t _size83;
-            ::apache::thrift::protocol::TType _ktype84;
-            ::apache::thrift::protocol::TType _vtype85;
-            xfer += iprot->readMapBegin(_ktype84, _vtype85, _size83);
-            uint32_t _i87;
-            for (_i87 = 0; _i87 < _size83; ++_i87)
+            uint32_t _size93;
+            ::apache::thrift::protocol::TType _ktype94;
+            ::apache::thrift::protocol::TType _vtype95;
+            xfer += iprot->readMapBegin(_ktype94, _vtype95, _size93);
+            uint32_t _i97;
+            for (_i97 = 0; _i97 < _size93; ++_i97)
             {
-              std::string _key88;
-              xfer += iprot->readString(_key88);
-              std::string& _val89 = this->queryAttributes[_key88];
-              xfer += iprot->readString(_val89);
+              std::string _key98;
+              xfer += iprot->readString(_key98);
+              std::string& _val99 = this->queryAttributes[_key98];
+              xfer += iprot->readString(_val99);
             }
             xfer += iprot->readMapEnd();
           }
@@ -1046,17 +1384,17 @@ uint32_t Query::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->queryCounters.clear();
-            uint32_t _size90;
-            ::apache::thrift::protocol::TType _ktype91;
-            ::apache::thrift::protocol::TType _vtype92;
-            xfer += iprot->readMapBegin(_ktype91, _vtype92, _size90);
-            uint32_t _i94;
-            for (_i94 = 0; _i94 < _size90; ++_i94)
+            uint32_t _size100;
+            ::apache::thrift::protocol::TType _ktype101;
+            ::apache::thrift::protocol::TType _vtype102;
+            xfer += iprot->readMapBegin(_ktype101, _vtype102, _size100);
+            uint32_t _i104;
+            for (_i104 = 0; _i104 < _size100; ++_i104)
             {
-              std::string _key95;
-              xfer += iprot->readString(_key95);
-              int64_t& _val96 = this->queryCounters[_key95];
-              xfer += iprot->readI64(_val96);
+              std::string _key105;
+              xfer += iprot->readString(_key105);
+              int64_t& _val106 = this->queryCounters[_key105];
+              xfer += iprot->readI64(_val106);
             }
             xfer += iprot->readMapEnd();
           }
@@ -1077,14 +1415,14 @@ uint32_t Query::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->stageList.clear();
-            uint32_t _size97;
-            ::apache::thrift::protocol::TType _etype100;
-            xfer += iprot->readListBegin(_etype100, _size97);
-            this->stageList.resize(_size97);
-            uint32_t _i101;
-            for (_i101 = 0; _i101 < _size97; ++_i101)
+            uint32_t _size107;
+            ::apache::thrift::protocol::TType _etype110;
+            xfer += iprot->readListBegin(_etype110, _size107);
+            this->stageList.resize(_size107);
+            uint32_t _i111;
+            for (_i111 = 0; _i111 < _size107; ++_i111)
             {
-              xfer += this->stageList[_i101].read(iprot);
+              xfer += this->stageList[_i111].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1123,6 +1461,7 @@ uint32_t Query::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Query");
 
   xfer += oprot->writeFieldBegin("queryId", ::apache::thrift::protocol::T_STRING, 1);
@@ -1136,11 +1475,11 @@ uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("queryAttributes", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->queryAttributes.size()));
-    std::map<std::string, std::string> ::const_iterator _iter102;
-    for (_iter102 = this->queryAttributes.begin(); _iter102 != this->queryAttributes.end(); ++_iter102)
+    std::map<std::string, std::string> ::const_iterator _iter112;
+    for (_iter112 = this->queryAttributes.begin(); _iter112 != this->queryAttributes.end(); ++_iter112)
     {
-      xfer += oprot->writeString(_iter102->first);
-      xfer += oprot->writeString(_iter102->second);
+      xfer += oprot->writeString(_iter112->first);
+      xfer += oprot->writeString(_iter112->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1149,11 +1488,11 @@ uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("queryCounters", ::apache::thrift::protocol::T_MAP, 4);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->queryCounters.size()));
-    std::map<std::string, int64_t> ::const_iterator _iter103;
-    for (_iter103 = this->queryCounters.begin(); _iter103 != this->queryCounters.end(); ++_iter103)
+    std::map<std::string, int64_t> ::const_iterator _iter113;
+    for (_iter113 = this->queryCounters.begin(); _iter113 != this->queryCounters.end(); ++_iter113)
     {
-      xfer += oprot->writeString(_iter103->first);
-      xfer += oprot->writeI64(_iter103->second);
+      xfer += oprot->writeString(_iter113->first);
+      xfer += oprot->writeI64(_iter113->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -1166,10 +1505,10 @@ uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("stageList", ::apache::thrift::protocol::T_LIST, 6);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->stageList.size()));
-    std::vector<Stage> ::const_iterator _iter104;
-    for (_iter104 = this->stageList.begin(); _iter104 != this->stageList.end(); ++_iter104)
+    std::vector<Stage> ::const_iterator _iter114;
+    for (_iter114 = this->stageList.begin(); _iter114 != this->stageList.end(); ++_iter114)
     {
-      xfer += (*_iter104).write(oprot);
+      xfer += (*_iter114).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1185,6 +1524,7 @@ uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1201,6 +1541,61 @@ void swap(Query &a, Query &b) {
   swap(a.__isset, b.__isset);
 }
 
+Query::Query(const Query& other115) {
+  queryId = other115.queryId;
+  queryType = other115.queryType;
+  queryAttributes = other115.queryAttributes;
+  queryCounters = other115.queryCounters;
+  stageGraph = other115.stageGraph;
+  stageList = other115.stageList;
+  done = other115.done;
+  started = other115.started;
+  __isset = other115.__isset;
+}
+Query& Query::operator=(const Query& other116) {
+  queryId = other116.queryId;
+  queryType = other116.queryType;
+  queryAttributes = other116.queryAttributes;
+  queryCounters = other116.queryCounters;
+  stageGraph = other116.stageGraph;
+  stageList = other116.stageList;
+  done = other116.done;
+  started = other116.started;
+  __isset = other116.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Query& obj) {
+  using apache::thrift::to_string;
+  out << "Query(";
+  out << "queryId=" << to_string(obj.queryId);
+  out << ", " << "queryType=" << to_string(obj.queryType);
+  out << ", " << "queryAttributes=" << to_string(obj.queryAttributes);
+  out << ", " << "queryCounters=" << to_string(obj.queryCounters);
+  out << ", " << "stageGraph=" << to_string(obj.stageGraph);
+  out << ", " << "stageList=" << to_string(obj.stageList);
+  out << ", " << "done=" << to_string(obj.done);
+  out << ", " << "started=" << to_string(obj.started);
+  out << ")";
+  return out;
+}
+
+
+QueryPlan::~QueryPlan() throw() {
+}
+
+
+void QueryPlan::__set_queries(const std::vector<Query> & val) {
+  this->queries = val;
+}
+
+void QueryPlan::__set_done(const bool val) {
+  this->done = val;
+}
+
+void QueryPlan::__set_started(const bool val) {
+  this->started = val;
+}
+
 const char* QueryPlan::ascii_fingerprint = "3418D1B0C20C288C8406186700B772E3";
 const uint8_t QueryPlan::binary_fingerprint[16] = {0x34,0x18,0xD1,0xB0,0xC2,0x0C,0x28,0x8C,0x84,0x06,0x18,0x67,0x00,0xB7,0x72,0xE3};
 
@@ -1228,14 +1623,14 @@ uint32_t QueryPlan::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->queries.clear();
-            uint32_t _size105;
-            ::apache::thrift::protocol::TType _etype108;
-            xfer += iprot->readListBegin(_etype108, _size105);
-            this->queries.resize(_size105);
-            uint32_t _i109;
-            for (_i109 = 0; _i109 < _size105; ++_i109)
+            uint32_t _size117;
+            ::apache::thrift::protocol::TType _etype120;
+            xfer += iprot->readListBegin(_etype120, _size117);
+            this->queries.resize(_size117);
+            uint32_t _i121;
+            for (_i121 = 0; _i121 < _size117; ++_i121)
             {
-              xfer += this->queries[_i109].read(iprot);
+              xfer += this->queries[_i121].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1274,15 +1669,16 @@ uint32_t QueryPlan::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t QueryPlan::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("QueryPlan");
 
   xfer += oprot->writeFieldBegin("queries", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->queries.size()));
-    std::vector<Query> ::const_iterator _iter110;
-    for (_iter110 = this->queries.begin(); _iter110 != this->queries.end(); ++_iter110)
+    std::vector<Query> ::const_iterator _iter122;
+    for (_iter122 = this->queries.begin(); _iter122 != this->queries.end(); ++_iter122)
     {
-      xfer += (*_iter110).write(oprot);
+      xfer += (*_iter122).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1298,6 +1694,7 @@ uint32_t QueryPlan::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1309,4 +1706,27 @@ void swap(QueryPlan &a, QueryPlan &b) {
   swap(a.__isset, b.__isset);
 }
 
+QueryPlan::QueryPlan(const QueryPlan& other123) {
+  queries = other123.queries;
+  done = other123.done;
+  started = other123.started;
+  __isset = other123.__isset;
+}
+QueryPlan& QueryPlan::operator=(const QueryPlan& other124) {
+  queries = other124.queries;
+  done = other124.done;
+  started = other124.started;
+  __isset = other124.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const QueryPlan& obj) {
+  using apache::thrift::to_string;
+  out << "QueryPlan(";
+  out << "queries=" << to_string(obj.queries);
+  out << ", " << "done=" << to_string(obj.done);
+  out << ", " << "started=" << to_string(obj.started);
+  out << ")";
+  return out;
+}
+
 }}} // namespace

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/ql/src/gen/thrift/gen-cpp/queryplan_types.h
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-cpp/queryplan_types.h b/ql/src/gen/thrift/gen-cpp/queryplan_types.h
index ac73bc5..932804d 100644
--- a/ql/src/gen/thrift/gen-cpp/queryplan_types.h
+++ b/ql/src/gen/thrift/gen-cpp/queryplan_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,11 +7,14 @@
 #ifndef queryplan_TYPES_H
 #define queryplan_TYPES_H
 
+#include <iosfwd>
+
 #include <thrift/Thrift.h>
 #include <thrift/TApplicationException.h>
 #include <thrift/protocol/TProtocol.h>
 #include <thrift/transport/TTransport.h>
 
+#include <thrift/cxxfunctional.h>
 
 
 namespace Apache { namespace Hadoop { namespace Hive {
@@ -60,7 +63,8 @@ struct OperatorType {
     EVENT = 21,
     ORCFILEMERGE = 22,
     RCFILEMERGE = 23,
-    MERGEJOIN = 24
+    MERGEJOIN = 24,
+    SPARKPRUNINGSINK = 25
   };
 };
 
@@ -95,11 +99,25 @@ struct StageType {
 
 extern const std::map<int, const char*> _StageType_VALUES_TO_NAMES;
 
+class Adjacency;
+
+class Graph;
+
+class Operator;
+
+class Task;
+
+class Stage;
+
+class Query;
+
+class QueryPlan;
+
 typedef struct _Adjacency__isset {
   _Adjacency__isset() : node(false), children(false), adjacencyType(false) {}
-  bool node;
-  bool children;
-  bool adjacencyType;
+  bool node :1;
+  bool children :1;
+  bool adjacencyType :1;
 } _Adjacency__isset;
 
 class Adjacency {
@@ -108,28 +126,23 @@ class Adjacency {
   static const char* ascii_fingerprint; // = "BC4F8C394677A1003AA9F56ED26D8204";
   static const uint8_t binary_fingerprint[16]; // = {0xBC,0x4F,0x8C,0x39,0x46,0x77,0xA1,0x00,0x3A,0xA9,0xF5,0x6E,0xD2,0x6D,0x82,0x04};
 
+  Adjacency(const Adjacency&);
+  Adjacency& operator=(const Adjacency&);
   Adjacency() : node(), adjacencyType((AdjacencyType::type)0) {
   }
 
-  virtual ~Adjacency() throw() {}
-
+  virtual ~Adjacency() throw();
   std::string node;
   std::vector<std::string>  children;
   AdjacencyType::type adjacencyType;
 
   _Adjacency__isset __isset;
 
-  void __set_node(const std::string& val) {
-    node = val;
-  }
+  void __set_node(const std::string& val);
 
-  void __set_children(const std::vector<std::string> & val) {
-    children = val;
-  }
+  void __set_children(const std::vector<std::string> & val);
 
-  void __set_adjacencyType(const AdjacencyType::type val) {
-    adjacencyType = val;
-  }
+  void __set_adjacencyType(const AdjacencyType::type val);
 
   bool operator == (const Adjacency & rhs) const
   {
@@ -150,15 +163,16 @@ class Adjacency {
   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 Adjacency& obj);
 };
 
 void swap(Adjacency &a, Adjacency &b);
 
 typedef struct _Graph__isset {
   _Graph__isset() : nodeType(false), roots(false), adjacencyList(false) {}
-  bool nodeType;
-  bool roots;
-  bool adjacencyList;
+  bool nodeType :1;
+  bool roots :1;
+  bool adjacencyList :1;
 } _Graph__isset;
 
 class Graph {
@@ -167,28 +181,23 @@ class Graph {
   static const char* ascii_fingerprint; // = "1F7FB604B3EF8F7AFB5DEAD15F2FC0B5";
   static const uint8_t binary_fingerprint[16]; // = {0x1F,0x7F,0xB6,0x04,0xB3,0xEF,0x8F,0x7A,0xFB,0x5D,0xEA,0xD1,0x5F,0x2F,0xC0,0xB5};
 
+  Graph(const Graph&);
+  Graph& operator=(const Graph&);
   Graph() : nodeType((NodeType::type)0) {
   }
 
-  virtual ~Graph() throw() {}
-
+  virtual ~Graph() throw();
   NodeType::type nodeType;
   std::vector<std::string>  roots;
   std::vector<Adjacency>  adjacencyList;
 
   _Graph__isset __isset;
 
-  void __set_nodeType(const NodeType::type val) {
-    nodeType = val;
-  }
+  void __set_nodeType(const NodeType::type val);
 
-  void __set_roots(const std::vector<std::string> & val) {
-    roots = val;
-  }
+  void __set_roots(const std::vector<std::string> & val);
 
-  void __set_adjacencyList(const std::vector<Adjacency> & val) {
-    adjacencyList = val;
-  }
+  void __set_adjacencyList(const std::vector<Adjacency> & val);
 
   bool operator == (const Graph & rhs) const
   {
@@ -209,18 +218,19 @@ class Graph {
   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 Graph& obj);
 };
 
 void swap(Graph &a, Graph &b);
 
 typedef struct _Operator__isset {
   _Operator__isset() : operatorId(false), operatorType(false), operatorAttributes(false), operatorCounters(false), done(false), started(false) {}
-  bool operatorId;
-  bool operatorType;
-  bool operatorAttributes;
-  bool operatorCounters;
-  bool done;
-  bool started;
+  bool operatorId :1;
+  bool operatorType :1;
+  bool operatorAttributes :1;
+  bool operatorCounters :1;
+  bool done :1;
+  bool started :1;
 } _Operator__isset;
 
 class Operator {
@@ -229,11 +239,12 @@ class Operator {
   static const char* ascii_fingerprint; // = "30917C758A752485AF223B697479DE6C";
   static const uint8_t binary_fingerprint[16]; // = {0x30,0x91,0x7C,0x75,0x8A,0x75,0x24,0x85,0xAF,0x22,0x3B,0x69,0x74,0x79,0xDE,0x6C};
 
+  Operator(const Operator&);
+  Operator& operator=(const Operator&);
   Operator() : operatorId(), operatorType((OperatorType::type)0), done(0), started(0) {
   }
 
-  virtual ~Operator() throw() {}
-
+  virtual ~Operator() throw();
   std::string operatorId;
   OperatorType::type operatorType;
   std::map<std::string, std::string>  operatorAttributes;
@@ -243,29 +254,17 @@ class Operator {
 
   _Operator__isset __isset;
 
-  void __set_operatorId(const std::string& val) {
-    operatorId = val;
-  }
+  void __set_operatorId(const std::string& val);
 
-  void __set_operatorType(const OperatorType::type val) {
-    operatorType = val;
-  }
+  void __set_operatorType(const OperatorType::type val);
 
-  void __set_operatorAttributes(const std::map<std::string, std::string> & val) {
-    operatorAttributes = val;
-  }
+  void __set_operatorAttributes(const std::map<std::string, std::string> & val);
 
-  void __set_operatorCounters(const std::map<std::string, int64_t> & val) {
-    operatorCounters = val;
-  }
+  void __set_operatorCounters(const std::map<std::string, int64_t> & val);
 
-  void __set_done(const bool val) {
-    done = val;
-  }
+  void __set_done(const bool val);
 
-  void __set_started(const bool val) {
-    started = val;
-  }
+  void __set_started(const bool val);
 
   bool operator == (const Operator & rhs) const
   {
@@ -292,20 +291,21 @@ class Operator {
   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 Operator& obj);
 };
 
 void swap(Operator &a, Operator &b);
 
 typedef struct _Task__isset {
   _Task__isset() : taskId(false), taskType(false), taskAttributes(false), taskCounters(false), operatorGraph(false), operatorList(false), done(false), started(false) {}
-  bool taskId;
-  bool taskType;
-  bool taskAttributes;
-  bool taskCounters;
-  bool operatorGraph;
-  bool operatorList;
-  bool done;
-  bool started;
+  bool taskId :1;
+  bool taskType :1;
+  bool taskAttributes :1;
+  bool taskCounters :1;
+  bool operatorGraph :1;
+  bool operatorList :1;
+  bool done :1;
+  bool started :1;
 } _Task__isset;
 
 class Task {
@@ -314,11 +314,12 @@ class Task {
   static const char* ascii_fingerprint; // = "AC741A136EFA51843AFC3A12F6A793D1";
   static const uint8_t binary_fingerprint[16]; // = {0xAC,0x74,0x1A,0x13,0x6E,0xFA,0x51,0x84,0x3A,0xFC,0x3A,0x12,0xF6,0xA7,0x93,0xD1};
 
+  Task(const Task&);
+  Task& operator=(const Task&);
   Task() : taskId(), taskType((TaskType::type)0), done(0), started(0) {
   }
 
-  virtual ~Task() throw() {}
-
+  virtual ~Task() throw();
   std::string taskId;
   TaskType::type taskType;
   std::map<std::string, std::string>  taskAttributes;
@@ -330,39 +331,21 @@ class Task {
 
   _Task__isset __isset;
 
-  void __set_taskId(const std::string& val) {
-    taskId = val;
-  }
+  void __set_taskId(const std::string& val);
 
-  void __set_taskType(const TaskType::type val) {
-    taskType = val;
-  }
+  void __set_taskType(const TaskType::type val);
 
-  void __set_taskAttributes(const std::map<std::string, std::string> & val) {
-    taskAttributes = val;
-  }
+  void __set_taskAttributes(const std::map<std::string, std::string> & val);
 
-  void __set_taskCounters(const std::map<std::string, int64_t> & val) {
-    taskCounters = val;
-  }
+  void __set_taskCounters(const std::map<std::string, int64_t> & val);
 
-  void __set_operatorGraph(const Graph& val) {
-    operatorGraph = val;
-    __isset.operatorGraph = true;
-  }
+  void __set_operatorGraph(const Graph& val);
 
-  void __set_operatorList(const std::vector<Operator> & val) {
-    operatorList = val;
-    __isset.operatorList = true;
-  }
+  void __set_operatorList(const std::vector<Operator> & val);
 
-  void __set_done(const bool val) {
-    done = val;
-  }
+  void __set_done(const bool val);
 
-  void __set_started(const bool val) {
-    started = val;
-  }
+  void __set_started(const bool val);
 
   bool operator == (const Task & rhs) const
   {
@@ -397,19 +380,20 @@ class Task {
   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 Task& obj);
 };
 
 void swap(Task &a, Task &b);
 
 typedef struct _Stage__isset {
   _Stage__isset() : stageId(false), stageType(false), stageAttributes(false), stageCounters(false), taskList(false), done(false), started(false) {}
-  bool stageId;
-  bool stageType;
-  bool stageAttributes;
-  bool stageCounters;
-  bool taskList;
-  bool done;
-  bool started;
+  bool stageId :1;
+  bool stageType :1;
+  bool stageAttributes :1;
+  bool stageCounters :1;
+  bool taskList :1;
+  bool done :1;
+  bool started :1;
 } _Stage__isset;
 
 class Stage {
@@ -418,11 +402,12 @@ class Stage {
   static const char* ascii_fingerprint; // = "86EA3C7B0690AFED21A3D479E2B32378";
   static const uint8_t binary_fingerprint[16]; // = {0x86,0xEA,0x3C,0x7B,0x06,0x90,0xAF,0xED,0x21,0xA3,0xD4,0x79,0xE2,0xB3,0x23,0x78};
 
+  Stage(const Stage&);
+  Stage& operator=(const Stage&);
   Stage() : stageId(), stageType((StageType::type)0), done(0), started(0) {
   }
 
-  virtual ~Stage() throw() {}
-
+  virtual ~Stage() throw();
   std::string stageId;
   StageType::type stageType;
   std::map<std::string, std::string>  stageAttributes;
@@ -433,33 +418,19 @@ class Stage {
 
   _Stage__isset __isset;
 
-  void __set_stageId(const std::string& val) {
-    stageId = val;
-  }
+  void __set_stageId(const std::string& val);
 
-  void __set_stageType(const StageType::type val) {
-    stageType = val;
-  }
+  void __set_stageType(const StageType::type val);
 
-  void __set_stageAttributes(const std::map<std::string, std::string> & val) {
-    stageAttributes = val;
-  }
+  void __set_stageAttributes(const std::map<std::string, std::string> & val);
 
-  void __set_stageCounters(const std::map<std::string, int64_t> & val) {
-    stageCounters = val;
-  }
+  void __set_stageCounters(const std::map<std::string, int64_t> & val);
 
-  void __set_taskList(const std::vector<Task> & val) {
-    taskList = val;
-  }
+  void __set_taskList(const std::vector<Task> & val);
 
-  void __set_done(const bool val) {
-    done = val;
-  }
+  void __set_done(const bool val);
 
-  void __set_started(const bool val) {
-    started = val;
-  }
+  void __set_started(const bool val);
 
   bool operator == (const Stage & rhs) const
   {
@@ -488,20 +459,21 @@ class Stage {
   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 Stage& obj);
 };
 
 void swap(Stage &a, Stage &b);
 
 typedef struct _Query__isset {
   _Query__isset() : queryId(false), queryType(false), queryAttributes(false), queryCounters(false), stageGraph(false), stageList(false), done(false), started(false) {}
-  bool queryId;
-  bool queryType;
-  bool queryAttributes;
-  bool queryCounters;
-  bool stageGraph;
-  bool stageList;
-  bool done;
-  bool started;
+  bool queryId :1;
+  bool queryType :1;
+  bool queryAttributes :1;
+  bool queryCounters :1;
+  bool stageGraph :1;
+  bool stageList :1;
+  bool done :1;
+  bool started :1;
 } _Query__isset;
 
 class Query {
@@ -510,11 +482,12 @@ class Query {
   static const char* ascii_fingerprint; // = "68300D63A5D40F2D17B9A9440FF626C1";
   static const uint8_t binary_fingerprint[16]; // = {0x68,0x30,0x0D,0x63,0xA5,0xD4,0x0F,0x2D,0x17,0xB9,0xA9,0x44,0x0F,0xF6,0x26,0xC1};
 
+  Query(const Query&);
+  Query& operator=(const Query&);
   Query() : queryId(), queryType(), done(0), started(0) {
   }
 
-  virtual ~Query() throw() {}
-
+  virtual ~Query() throw();
   std::string queryId;
   std::string queryType;
   std::map<std::string, std::string>  queryAttributes;
@@ -526,37 +499,21 @@ class Query {
 
   _Query__isset __isset;
 
-  void __set_queryId(const std::string& val) {
-    queryId = val;
-  }
+  void __set_queryId(const std::string& val);
 
-  void __set_queryType(const std::string& val) {
-    queryType = val;
-  }
+  void __set_queryType(const std::string& val);
 
-  void __set_queryAttributes(const std::map<std::string, std::string> & val) {
-    queryAttributes = val;
-  }
+  void __set_queryAttributes(const std::map<std::string, std::string> & val);
 
-  void __set_queryCounters(const std::map<std::string, int64_t> & val) {
-    queryCounters = val;
-  }
+  void __set_queryCounters(const std::map<std::string, int64_t> & val);
 
-  void __set_stageGraph(const Graph& val) {
-    stageGraph = val;
-  }
+  void __set_stageGraph(const Graph& val);
 
-  void __set_stageList(const std::vector<Stage> & val) {
-    stageList = val;
-  }
+  void __set_stageList(const std::vector<Stage> & val);
 
-  void __set_done(const bool val) {
-    done = val;
-  }
+  void __set_done(const bool val);
 
-  void __set_started(const bool val) {
-    started = val;
-  }
+  void __set_started(const bool val);
 
   bool operator == (const Query & rhs) const
   {
@@ -587,15 +544,16 @@ class Query {
   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 Query& obj);
 };
 
 void swap(Query &a, Query &b);
 
 typedef struct _QueryPlan__isset {
   _QueryPlan__isset() : queries(false), done(false), started(false) {}
-  bool queries;
-  bool done;
-  bool started;
+  bool queries :1;
+  bool done :1;
+  bool started :1;
 } _QueryPlan__isset;
 
 class QueryPlan {
@@ -604,28 +562,23 @@ class QueryPlan {
   static const char* ascii_fingerprint; // = "3418D1B0C20C288C8406186700B772E3";
   static const uint8_t binary_fingerprint[16]; // = {0x34,0x18,0xD1,0xB0,0xC2,0x0C,0x28,0x8C,0x84,0x06,0x18,0x67,0x00,0xB7,0x72,0xE3};
 
+  QueryPlan(const QueryPlan&);
+  QueryPlan& operator=(const QueryPlan&);
   QueryPlan() : done(0), started(0) {
   }
 
-  virtual ~QueryPlan() throw() {}
-
+  virtual ~QueryPlan() throw();
   std::vector<Query>  queries;
   bool done;
   bool started;
 
   _QueryPlan__isset __isset;
 
-  void __set_queries(const std::vector<Query> & val) {
-    queries = val;
-  }
+  void __set_queries(const std::vector<Query> & val);
 
-  void __set_done(const bool val) {
-    done = val;
-  }
+  void __set_done(const bool val);
 
-  void __set_started(const bool val) {
-    started = val;
-  }
+  void __set_started(const bool val);
 
   bool operator == (const QueryPlan & rhs) const
   {
@@ -646,6 +599,7 @@ class QueryPlan {
   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 QueryPlan& obj);
 };
 
 void swap(QueryPlan &a, QueryPlan &b);

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java
index 22ca225..b71f4ae 100644
--- a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java
+++ b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java
@@ -1,12 +1,11 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
  */
 package org.apache.hadoop.hive.ql.plan.api;
 
-import org.apache.commons.lang.builder.HashCodeBuilder;
 import org.apache.thrift.scheme.IScheme;
 import org.apache.thrift.scheme.SchemeFactory;
 import org.apache.thrift.scheme.StandardScheme;
@@ -16,6 +15,8 @@ import org.apache.thrift.protocol.TTupleProtocol;
 import org.apache.thrift.protocol.TProtocolException;
 import org.apache.thrift.EncodingUtils;
 import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Map;
@@ -28,10 +29,13 @@ import java.util.Collections;
 import java.util.BitSet;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import javax.annotation.Generated;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._Fields>, java.io.Serializable, Cloneable {
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-7-14")
+public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._Fields>, java.io.Serializable, Cloneable, Comparable<Adjacency> {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Adjacency");
 
   private static final org.apache.thrift.protocol.TField NODE_FIELD_DESC = new org.apache.thrift.protocol.TField("node", org.apache.thrift.protocol.TType.STRING, (short)1);
@@ -153,10 +157,7 @@ public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._
       this.node = other.node;
     }
     if (other.isSetChildren()) {
-      List<String> __this__children = new ArrayList<String>();
-      for (String other_element : other.children) {
-        __this__children.add(other_element);
-      }
+      List<String> __this__children = new ArrayList<String>(other.children);
       this.children = __this__children;
     }
     if (other.isSetAdjacencyType()) {
@@ -373,60 +374,60 @@ public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._
 
   @Override
   public int hashCode() {
-    HashCodeBuilder builder = new HashCodeBuilder();
+    List<Object> list = new ArrayList<Object>();
 
     boolean present_node = true && (isSetNode());
-    builder.append(present_node);
+    list.add(present_node);
     if (present_node)
-      builder.append(node);
+      list.add(node);
 
     boolean present_children = true && (isSetChildren());
-    builder.append(present_children);
+    list.add(present_children);
     if (present_children)
-      builder.append(children);
+      list.add(children);
 
     boolean present_adjacencyType = true && (isSetAdjacencyType());
-    builder.append(present_adjacencyType);
+    list.add(present_adjacencyType);
     if (present_adjacencyType)
-      builder.append(adjacencyType.getValue());
+      list.add(adjacencyType.getValue());
 
-    return builder.toHashCode();
+    return list.hashCode();
   }
 
+  @Override
   public int compareTo(Adjacency other) {
     if (!getClass().equals(other.getClass())) {
       return getClass().getName().compareTo(other.getClass().getName());
     }
 
     int lastComparison = 0;
-    Adjacency typedOther = (Adjacency)other;
 
-    lastComparison = Boolean.valueOf(isSetNode()).compareTo(typedOther.isSetNode());
+    lastComparison = Boolean.valueOf(isSetNode()).compareTo(other.isSetNode());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetNode()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.node, typedOther.node);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.node, other.node);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetChildren()).compareTo(typedOther.isSetChildren());
+    lastComparison = Boolean.valueOf(isSetChildren()).compareTo(other.isSetChildren());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetChildren()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.children, typedOther.children);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.children, other.children);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetAdjacencyType()).compareTo(typedOther.isSetAdjacencyType());
+    lastComparison = Boolean.valueOf(isSetAdjacencyType()).compareTo(other.isSetAdjacencyType());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetAdjacencyType()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.adjacencyType, typedOther.adjacencyType);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.adjacencyType, other.adjacencyType);
       if (lastComparison != 0) {
         return lastComparison;
       }
@@ -530,11 +531,11 @@ public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._
               {
                 org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
                 struct.children = new ArrayList<String>(_list0.size);
-                for (int _i1 = 0; _i1 < _list0.size; ++_i1)
+                String _elem1;
+                for (int _i2 = 0; _i2 < _list0.size; ++_i2)
                 {
-                  String _elem2; // required
-                  _elem2 = iprot.readString();
-                  struct.children.add(_elem2);
+                  _elem1 = iprot.readString();
+                  struct.children.add(_elem1);
                 }
                 iprot.readListEnd();
               }
@@ -545,7 +546,7 @@ public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._
             break;
           case 3: // ADJACENCY_TYPE
             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
-              struct.adjacencyType = AdjacencyType.findByValue(iprot.readI32());
+              struct.adjacencyType = org.apache.hadoop.hive.ql.plan.api.AdjacencyType.findByValue(iprot.readI32());
               struct.setAdjacencyTypeIsSet(true);
             } else { 
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
@@ -643,17 +644,17 @@ public class Adjacency implements org.apache.thrift.TBase<Adjacency, Adjacency._
         {
           org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
           struct.children = new ArrayList<String>(_list5.size);
-          for (int _i6 = 0; _i6 < _list5.size; ++_i6)
+          String _elem6;
+          for (int _i7 = 0; _i7 < _list5.size; ++_i7)
           {
-            String _elem7; // required
-            _elem7 = iprot.readString();
-            struct.children.add(_elem7);
+            _elem6 = iprot.readString();
+            struct.children.add(_elem6);
           }
         }
         struct.setChildrenIsSet(true);
       }
       if (incoming.get(2)) {
-        struct.adjacencyType = AdjacencyType.findByValue(iprot.readI32());
+        struct.adjacencyType = org.apache.hadoop.hive.ql.plan.api.AdjacencyType.findByValue(iprot.readI32());
         struct.setAdjacencyTypeIsSet(true);
       }
     }

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java
index 7984d4e..470cad2 100644
--- a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java
+++ b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * 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/42216997/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Graph.java
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Graph.java b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Graph.java
index 35aa6cb..d02c86d 100644
--- a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Graph.java
+++ b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Graph.java
@@ -1,12 +1,11 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
  */
 package org.apache.hadoop.hive.ql.plan.api;
 
-import org.apache.commons.lang.builder.HashCodeBuilder;
 import org.apache.thrift.scheme.IScheme;
 import org.apache.thrift.scheme.SchemeFactory;
 import org.apache.thrift.scheme.StandardScheme;
@@ -16,6 +15,8 @@ import org.apache.thrift.protocol.TTupleProtocol;
 import org.apache.thrift.protocol.TProtocolException;
 import org.apache.thrift.EncodingUtils;
 import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Map;
@@ -28,10 +29,13 @@ import java.util.Collections;
 import java.util.BitSet;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import javax.annotation.Generated;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, java.io.Serializable, Cloneable {
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.2)", date = "2015-7-14")
+public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, java.io.Serializable, Cloneable, Comparable<Graph> {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Graph");
 
   private static final org.apache.thrift.protocol.TField NODE_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("nodeType", org.apache.thrift.protocol.TType.I32, (short)1);
@@ -154,14 +158,11 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
       this.nodeType = other.nodeType;
     }
     if (other.isSetRoots()) {
-      List<String> __this__roots = new ArrayList<String>();
-      for (String other_element : other.roots) {
-        __this__roots.add(other_element);
-      }
+      List<String> __this__roots = new ArrayList<String>(other.roots);
       this.roots = __this__roots;
     }
     if (other.isSetAdjacencyList()) {
-      List<Adjacency> __this__adjacencyList = new ArrayList<Adjacency>();
+      List<Adjacency> __this__adjacencyList = new ArrayList<Adjacency>(other.adjacencyList.size());
       for (Adjacency other_element : other.adjacencyList) {
         __this__adjacencyList.add(new Adjacency(other_element));
       }
@@ -393,60 +394,60 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
 
   @Override
   public int hashCode() {
-    HashCodeBuilder builder = new HashCodeBuilder();
+    List<Object> list = new ArrayList<Object>();
 
     boolean present_nodeType = true && (isSetNodeType());
-    builder.append(present_nodeType);
+    list.add(present_nodeType);
     if (present_nodeType)
-      builder.append(nodeType.getValue());
+      list.add(nodeType.getValue());
 
     boolean present_roots = true && (isSetRoots());
-    builder.append(present_roots);
+    list.add(present_roots);
     if (present_roots)
-      builder.append(roots);
+      list.add(roots);
 
     boolean present_adjacencyList = true && (isSetAdjacencyList());
-    builder.append(present_adjacencyList);
+    list.add(present_adjacencyList);
     if (present_adjacencyList)
-      builder.append(adjacencyList);
+      list.add(adjacencyList);
 
-    return builder.toHashCode();
+    return list.hashCode();
   }
 
+  @Override
   public int compareTo(Graph other) {
     if (!getClass().equals(other.getClass())) {
       return getClass().getName().compareTo(other.getClass().getName());
     }
 
     int lastComparison = 0;
-    Graph typedOther = (Graph)other;
 
-    lastComparison = Boolean.valueOf(isSetNodeType()).compareTo(typedOther.isSetNodeType());
+    lastComparison = Boolean.valueOf(isSetNodeType()).compareTo(other.isSetNodeType());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetNodeType()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nodeType, typedOther.nodeType);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nodeType, other.nodeType);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetRoots()).compareTo(typedOther.isSetRoots());
+    lastComparison = Boolean.valueOf(isSetRoots()).compareTo(other.isSetRoots());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetRoots()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.roots, typedOther.roots);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.roots, other.roots);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
-    lastComparison = Boolean.valueOf(isSetAdjacencyList()).compareTo(typedOther.isSetAdjacencyList());
+    lastComparison = Boolean.valueOf(isSetAdjacencyList()).compareTo(other.isSetAdjacencyList());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetAdjacencyList()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.adjacencyList, typedOther.adjacencyList);
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.adjacencyList, other.adjacencyList);
       if (lastComparison != 0) {
         return lastComparison;
       }
@@ -539,7 +540,7 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
         switch (schemeField.id) {
           case 1: // NODE_TYPE
             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
-              struct.nodeType = NodeType.findByValue(iprot.readI32());
+              struct.nodeType = org.apache.hadoop.hive.ql.plan.api.NodeType.findByValue(iprot.readI32());
               struct.setNodeTypeIsSet(true);
             } else { 
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
@@ -550,11 +551,11 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
               {
                 org.apache.thrift.protocol.TList _list8 = iprot.readListBegin();
                 struct.roots = new ArrayList<String>(_list8.size);
-                for (int _i9 = 0; _i9 < _list8.size; ++_i9)
+                String _elem9;
+                for (int _i10 = 0; _i10 < _list8.size; ++_i10)
                 {
-                  String _elem10; // required
-                  _elem10 = iprot.readString();
-                  struct.roots.add(_elem10);
+                  _elem9 = iprot.readString();
+                  struct.roots.add(_elem9);
                 }
                 iprot.readListEnd();
               }
@@ -568,12 +569,12 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
               {
                 org.apache.thrift.protocol.TList _list11 = iprot.readListBegin();
                 struct.adjacencyList = new ArrayList<Adjacency>(_list11.size);
-                for (int _i12 = 0; _i12 < _list11.size; ++_i12)
+                Adjacency _elem12;
+                for (int _i13 = 0; _i13 < _list11.size; ++_i13)
                 {
-                  Adjacency _elem13; // required
-                  _elem13 = new Adjacency();
-                  _elem13.read(iprot);
-                  struct.adjacencyList.add(_elem13);
+                  _elem12 = new Adjacency();
+                  _elem12.read(iprot);
+                  struct.adjacencyList.add(_elem12);
                 }
                 iprot.readListEnd();
               }
@@ -680,18 +681,18 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
       TTupleProtocol iprot = (TTupleProtocol) prot;
       BitSet incoming = iprot.readBitSet(3);
       if (incoming.get(0)) {
-        struct.nodeType = NodeType.findByValue(iprot.readI32());
+        struct.nodeType = org.apache.hadoop.hive.ql.plan.api.NodeType.findByValue(iprot.readI32());
         struct.setNodeTypeIsSet(true);
       }
       if (incoming.get(1)) {
         {
           org.apache.thrift.protocol.TList _list18 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
           struct.roots = new ArrayList<String>(_list18.size);
-          for (int _i19 = 0; _i19 < _list18.size; ++_i19)
+          String _elem19;
+          for (int _i20 = 0; _i20 < _list18.size; ++_i20)
           {
-            String _elem20; // required
-            _elem20 = iprot.readString();
-            struct.roots.add(_elem20);
+            _elem19 = iprot.readString();
+            struct.roots.add(_elem19);
           }
         }
         struct.setRootsIsSet(true);
@@ -700,12 +701,12 @@ public class Graph implements org.apache.thrift.TBase<Graph, Graph._Fields>, jav
         {
           org.apache.thrift.protocol.TList _list21 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
           struct.adjacencyList = new ArrayList<Adjacency>(_list21.size);
-          for (int _i22 = 0; _i22 < _list21.size; ++_i22)
+          Adjacency _elem22;
+          for (int _i23 = 0; _i23 < _list21.size; ++_i23)
           {
-            Adjacency _elem23; // required
-            _elem23 = new Adjacency();
-            _elem23.read(iprot);
-            struct.adjacencyList.add(_elem23);
+            _elem22 = new Adjacency();
+            _elem22.read(iprot);
+            struct.adjacencyList.add(_elem22);
           }
         }
         struct.setAdjacencyListIsSet(true);

http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/NodeType.java
----------------------------------------------------------------------
diff --git a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/NodeType.java b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/NodeType.java
index 1126049..5fdbfa3 100644
--- a/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/NodeType.java
+++ b/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/NodeType.java
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated


Mime
View raw message