Return-Path: X-Original-To: apmail-hive-commits-archive@www.apache.org Delivered-To: apmail-hive-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id A5CEF18D75 for ; Fri, 31 Jul 2015 22:57:10 +0000 (UTC) Received: (qmail 15044 invoked by uid 500); 31 Jul 2015 22:57:04 -0000 Delivered-To: apmail-hive-commits-archive@hive.apache.org Received: (qmail 14939 invoked by uid 500); 31 Jul 2015 22:57:04 -0000 Mailing-List: contact commits-help@hive.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: hive-dev@hive.apache.org Delivered-To: mailing list commits@hive.apache.org Received: (qmail 13257 invoked by uid 99); 31 Jul 2015 22:57:03 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 31 Jul 2015 22:57:03 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id F2433E08E0; Fri, 31 Jul 2015 22:57:02 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: xuefu@apache.org To: commits@hive.apache.org Date: Fri, 31 Jul 2015 22:57:27 -0000 Message-Id: <813625f0397b4a33890929e59a0d082f@git.apache.org> In-Reply-To: <8ac17ffb2a0d4a9e83b90ea91818ea51@git.apache.org> References: <8ac17ffb2a0d4a9e83b90ea91818ea51@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [26/54] [abbrv] 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/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 +#include + +#include 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 _OperatorType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(25, _kOperatorTypeValues, _kOperatorTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); +const std::map _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 _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 & 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 & val) { + this->roots = val; +} + +void Graph::__set_adjacencyList(const std::vector & 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(this->roots.size())); - std::vector ::const_iterator _iter18; - for (_iter18 = this->roots.begin(); _iter18 != this->roots.end(); ++_iter18) + std::vector ::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(this->adjacencyList.size())); - std::vector ::const_iterator _iter19; - for (_iter19 = this->adjacencyList.begin(); _iter19 != this->adjacencyList.end(); ++_iter19) + std::vector ::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 & val) { + this->operatorAttributes = val; +} + +void Operator::__set_operatorCounters(const std::map & 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(this->operatorAttributes.size())); - std::map ::const_iterator _iter35; - for (_iter35 = this->operatorAttributes.begin(); _iter35 != this->operatorAttributes.end(); ++_iter35) + std::map ::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(this->operatorCounters.size())); - std::map ::const_iterator _iter36; - for (_iter36 = this->operatorCounters.begin(); _iter36 != this->operatorCounters.end(); ++_iter36) + std::map ::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 & val) { + this->taskAttributes = val; +} + +void Task::__set_taskCounters(const std::map & val) { + this->taskCounters = val; +} + +void Task::__set_operatorGraph(const Graph& val) { + this->operatorGraph = val; +__isset.operatorGraph = true; +} + +void Task::__set_operatorList(const std::vector & 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(this->taskAttributes.size())); - std::map ::const_iterator _iter57; - for (_iter57 = this->taskAttributes.begin(); _iter57 != this->taskAttributes.end(); ++_iter57) + std::map ::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(this->taskCounters.size())); - std::map ::const_iterator _iter58; - for (_iter58 = this->taskCounters.begin(); _iter58 != this->taskCounters.end(); ++_iter58) + std::map ::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(this->operatorList.size())); - std::vector ::const_iterator _iter59; - for (_iter59 = this->operatorList.begin(); _iter59 != this->operatorList.end(); ++_iter59) + std::vector ::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 << "")); + out << ", " << "operatorList="; (obj.__isset.operatorList ? (out << to_string(obj.operatorList)) : (out << "")); + 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 & val) { + this->stageAttributes = val; +} + +void Stage::__set_stageCounters(const std::map & val) { + this->stageCounters = val; +} + +void Stage::__set_taskList(const std::vector & 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(this->stageAttributes.size())); - std::map ::const_iterator _iter80; - for (_iter80 = this->stageAttributes.begin(); _iter80 != this->stageAttributes.end(); ++_iter80) + std::map ::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(this->stageCounters.size())); - std::map ::const_iterator _iter81; - for (_iter81 = this->stageCounters.begin(); _iter81 != this->stageCounters.end(); ++_iter81) + std::map ::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(this->taskList.size())); - std::vector ::const_iterator _iter82; - for (_iter82 = this->taskList.begin(); _iter82 != this->taskList.end(); ++_iter82) + std::vector ::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 & val) { + this->queryAttributes = val; +} + +void Query::__set_queryCounters(const std::map & val) { + this->queryCounters = val; +} + +void Query::__set_stageGraph(const Graph& val) { + this->stageGraph = val; +} + +void Query::__set_stageList(const std::vector & 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(this->queryAttributes.size())); - std::map ::const_iterator _iter102; - for (_iter102 = this->queryAttributes.begin(); _iter102 != this->queryAttributes.end(); ++_iter102) + std::map ::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(this->queryCounters.size())); - std::map ::const_iterator _iter103; - for (_iter103 = this->queryCounters.begin(); _iter103 != this->queryCounters.end(); ++_iter103) + std::map ::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(this->stageList.size())); - std::vector ::const_iterator _iter104; - for (_iter104 = this->stageList.begin(); _iter104 != this->stageList.end(); ++_iter104) + std::vector ::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 & 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(this->queries.size())); - std::vector ::const_iterator _iter110; - for (_iter110 = this->queries.begin(); _iter110 != this->queries.end(); ++_iter110) + std::vector ::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 + #include #include #include #include +#include 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 _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 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 & val) { - children = val; - } + void __set_children(const std::vector & 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 roots; std::vector 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 & val) { - roots = val; - } + void __set_roots(const std::vector & val); - void __set_adjacencyList(const std::vector & val) { - adjacencyList = val; - } + void __set_adjacencyList(const std::vector & 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 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 & val) { - operatorAttributes = val; - } + void __set_operatorAttributes(const std::map & val); - void __set_operatorCounters(const std::map & val) { - operatorCounters = val; - } + void __set_operatorCounters(const std::map & 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 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 & val) { - taskAttributes = val; - } + void __set_taskAttributes(const std::map & val); - void __set_taskCounters(const std::map & val) { - taskCounters = val; - } + void __set_taskCounters(const std::map & val); - void __set_operatorGraph(const Graph& val) { - operatorGraph = val; - __isset.operatorGraph = true; - } + void __set_operatorGraph(const Graph& val); - void __set_operatorList(const std::vector & val) { - operatorList = val; - __isset.operatorList = true; - } + void __set_operatorList(const std::vector & 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 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 & val) { - stageAttributes = val; - } + void __set_stageAttributes(const std::map & val); - void __set_stageCounters(const std::map & val) { - stageCounters = val; - } + void __set_stageCounters(const std::map & val); - void __set_taskList(const std::vector & val) { - taskList = val; - } + void __set_taskList(const std::vector & 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 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 & val) { - queryAttributes = val; - } + void __set_queryAttributes(const std::map & val); - void __set_queryCounters(const std::map & val) { - queryCounters = val; - } + void __set_queryCounters(const std::map & val); - void __set_stageGraph(const Graph& val) { - stageGraph = val; - } + void __set_stageGraph(const Graph& val); - void __set_stageList(const std::vector & val) { - stageList = val; - } + void __set_stageList(const std::vector & 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 queries; bool done; bool started; _QueryPlan__isset __isset; - void __set_queries(const std::vector & val) { - queries = val; - } + void __set_queries(const std::vector & 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, 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, java.io.Serializable, Cloneable, Comparable { 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 __this__children = new ArrayList(); - for (String other_element : other.children) { - __this__children.add(other_element); - } + List __this__children = new ArrayList(other.children); this.children = __this__children; } if (other.isSetAdjacencyType()) { @@ -373,60 +374,60 @@ public class Adjacency implements org.apache.thrift.TBase list = new ArrayList