You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by xu...@apache.org on 2015/08/02 05:59:12 UTC
[27/50] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark
Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)
http://git-wip-us.apache.org/repos/asf/hive/blob/d7413e4b/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/d7413e4b/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/d7413e4b/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/d7413e4b/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/d7413e4b/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/d7413e4b/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