Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id D44D1200AE4 for ; Tue, 10 May 2016 20:05:58 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id D1EFD160877; Tue, 10 May 2016 18:05:58 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id B3CDA160A18 for ; Tue, 10 May 2016 20:05:56 +0200 (CEST) Received: (qmail 28827 invoked by uid 500); 10 May 2016 18:05:55 -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 28287 invoked by uid 99); 10 May 2016 18:05:55 -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; Tue, 10 May 2016 18:05:55 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id DC614E0B71; Tue, 10 May 2016 18:05:54 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: weiz@apache.org To: commits@hive.apache.org Date: Tue, 10 May 2016 18:06:00 -0000 Message-Id: In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [7/8] hive git commit: HIVE-12634 : Add command to kill an ACID transacton (Wei Zheng, reviewed by Eugene Koifman) archived-at: Tue, 10 May 2016 18:05:59 -0000 http://git-wip-us.apache.org/repos/asf/hive/blob/aecb0c02/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 5efda4f..176b634 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->success.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + uint32_t _size657; + ::apache::thrift::protocol::TType _etype660; + xfer += iprot->readListBegin(_etype660, _size657); + this->success.resize(_size657); + uint32_t _i661; + for (_i661 = 0; _i661 < _size657; ++_i661) { - xfer += iprot->readString(this->success[_i653]); + xfer += iprot->readString(this->success[_i661]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter654; - for (_iter654 = this->success.begin(); _iter654 != this->success.end(); ++_iter654) + std::vector ::const_iterator _iter662; + for (_iter662 = this->success.begin(); _iter662 != this->success.end(); ++_iter662) { - xfer += oprot->writeString((*_iter654)); + xfer += oprot->writeString((*_iter662)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size655; - ::apache::thrift::protocol::TType _etype658; - xfer += iprot->readListBegin(_etype658, _size655); - (*(this->success)).resize(_size655); - uint32_t _i659; - for (_i659 = 0; _i659 < _size655; ++_i659) + uint32_t _size663; + ::apache::thrift::protocol::TType _etype666; + xfer += iprot->readListBegin(_etype666, _size663); + (*(this->success)).resize(_size663); + uint32_t _i667; + for (_i667 = 0; _i667 < _size663; ++_i667) { - xfer += iprot->readString((*(this->success))[_i659]); + xfer += iprot->readString((*(this->success))[_i667]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size660; - ::apache::thrift::protocol::TType _etype663; - xfer += iprot->readListBegin(_etype663, _size660); - this->success.resize(_size660); - uint32_t _i664; - for (_i664 = 0; _i664 < _size660; ++_i664) + uint32_t _size668; + ::apache::thrift::protocol::TType _etype671; + xfer += iprot->readListBegin(_etype671, _size668); + this->success.resize(_size668); + uint32_t _i672; + for (_i672 = 0; _i672 < _size668; ++_i672) { - xfer += iprot->readString(this->success[_i664]); + xfer += iprot->readString(this->success[_i672]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter665; - for (_iter665 = this->success.begin(); _iter665 != this->success.end(); ++_iter665) + std::vector ::const_iterator _iter673; + for (_iter673 = this->success.begin(); _iter673 != this->success.end(); ++_iter673) { - xfer += oprot->writeString((*_iter665)); + xfer += oprot->writeString((*_iter673)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size666; - ::apache::thrift::protocol::TType _etype669; - xfer += iprot->readListBegin(_etype669, _size666); - (*(this->success)).resize(_size666); - uint32_t _i670; - for (_i670 = 0; _i670 < _size666; ++_i670) + uint32_t _size674; + ::apache::thrift::protocol::TType _etype677; + xfer += iprot->readListBegin(_etype677, _size674); + (*(this->success)).resize(_size674); + uint32_t _i678; + for (_i678 = 0; _i678 < _size674; ++_i678) { - xfer += iprot->readString((*(this->success))[_i670]); + xfer += iprot->readString((*(this->success))[_i678]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size671; - ::apache::thrift::protocol::TType _ktype672; - ::apache::thrift::protocol::TType _vtype673; - xfer += iprot->readMapBegin(_ktype672, _vtype673, _size671); - uint32_t _i675; - for (_i675 = 0; _i675 < _size671; ++_i675) + uint32_t _size679; + ::apache::thrift::protocol::TType _ktype680; + ::apache::thrift::protocol::TType _vtype681; + xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); + uint32_t _i683; + for (_i683 = 0; _i683 < _size679; ++_i683) { - std::string _key676; - xfer += iprot->readString(_key676); - Type& _val677 = this->success[_key676]; - xfer += _val677.read(iprot); + std::string _key684; + xfer += iprot->readString(_key684); + Type& _val685 = this->success[_key684]; + xfer += _val685.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::map ::const_iterator _iter678; - for (_iter678 = this->success.begin(); _iter678 != this->success.end(); ++_iter678) + std::map ::const_iterator _iter686; + for (_iter686 = this->success.begin(); _iter686 != this->success.end(); ++_iter686) { - xfer += oprot->writeString(_iter678->first); - xfer += _iter678->second.write(oprot); + xfer += oprot->writeString(_iter686->first); + xfer += _iter686->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size679; - ::apache::thrift::protocol::TType _ktype680; - ::apache::thrift::protocol::TType _vtype681; - xfer += iprot->readMapBegin(_ktype680, _vtype681, _size679); - uint32_t _i683; - for (_i683 = 0; _i683 < _size679; ++_i683) + uint32_t _size687; + ::apache::thrift::protocol::TType _ktype688; + ::apache::thrift::protocol::TType _vtype689; + xfer += iprot->readMapBegin(_ktype688, _vtype689, _size687); + uint32_t _i691; + for (_i691 = 0; _i691 < _size687; ++_i691) { - std::string _key684; - xfer += iprot->readString(_key684); - Type& _val685 = (*(this->success))[_key684]; - xfer += _val685.read(iprot); + std::string _key692; + xfer += iprot->readString(_key692); + Type& _val693 = (*(this->success))[_key692]; + xfer += _val693.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size686; - ::apache::thrift::protocol::TType _etype689; - xfer += iprot->readListBegin(_etype689, _size686); - this->success.resize(_size686); - uint32_t _i690; - for (_i690 = 0; _i690 < _size686; ++_i690) + uint32_t _size694; + ::apache::thrift::protocol::TType _etype697; + xfer += iprot->readListBegin(_etype697, _size694); + this->success.resize(_size694); + uint32_t _i698; + for (_i698 = 0; _i698 < _size694; ++_i698) { - xfer += this->success[_i690].read(iprot); + xfer += this->success[_i698].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter691; - for (_iter691 = this->success.begin(); _iter691 != this->success.end(); ++_iter691) + std::vector ::const_iterator _iter699; + for (_iter699 = this->success.begin(); _iter699 != this->success.end(); ++_iter699) { - xfer += (*_iter691).write(oprot); + xfer += (*_iter699).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size692; - ::apache::thrift::protocol::TType _etype695; - xfer += iprot->readListBegin(_etype695, _size692); - (*(this->success)).resize(_size692); - uint32_t _i696; - for (_i696 = 0; _i696 < _size692; ++_i696) + uint32_t _size700; + ::apache::thrift::protocol::TType _etype703; + xfer += iprot->readListBegin(_etype703, _size700); + (*(this->success)).resize(_size700); + uint32_t _i704; + for (_i704 = 0; _i704 < _size700; ++_i704) { - xfer += (*(this->success))[_i696].read(iprot); + xfer += (*(this->success))[_i704].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size697; - ::apache::thrift::protocol::TType _etype700; - xfer += iprot->readListBegin(_etype700, _size697); - this->success.resize(_size697); - uint32_t _i701; - for (_i701 = 0; _i701 < _size697; ++_i701) + uint32_t _size705; + ::apache::thrift::protocol::TType _etype708; + xfer += iprot->readListBegin(_etype708, _size705); + this->success.resize(_size705); + uint32_t _i709; + for (_i709 = 0; _i709 < _size705; ++_i709) { - xfer += this->success[_i701].read(iprot); + xfer += this->success[_i709].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter702; - for (_iter702 = this->success.begin(); _iter702 != this->success.end(); ++_iter702) + std::vector ::const_iterator _iter710; + for (_iter710 = this->success.begin(); _iter710 != this->success.end(); ++_iter710) { - xfer += (*_iter702).write(oprot); + xfer += (*_iter710).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size703; - ::apache::thrift::protocol::TType _etype706; - xfer += iprot->readListBegin(_etype706, _size703); - (*(this->success)).resize(_size703); - uint32_t _i707; - for (_i707 = 0; _i707 < _size703; ++_i707) + uint32_t _size711; + ::apache::thrift::protocol::TType _etype714; + xfer += iprot->readListBegin(_etype714, _size711); + (*(this->success)).resize(_size711); + uint32_t _i715; + for (_i715 = 0; _i715 < _size711; ++_i715) { - xfer += (*(this->success))[_i707].read(iprot); + xfer += (*(this->success))[_i715].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size708; - ::apache::thrift::protocol::TType _etype711; - xfer += iprot->readListBegin(_etype711, _size708); - this->success.resize(_size708); - uint32_t _i712; - for (_i712 = 0; _i712 < _size708; ++_i712) + uint32_t _size716; + ::apache::thrift::protocol::TType _etype719; + xfer += iprot->readListBegin(_etype719, _size716); + this->success.resize(_size716); + uint32_t _i720; + for (_i720 = 0; _i720 < _size716; ++_i720) { - xfer += this->success[_i712].read(iprot); + xfer += this->success[_i720].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter713; - for (_iter713 = this->success.begin(); _iter713 != this->success.end(); ++_iter713) + std::vector ::const_iterator _iter721; + for (_iter721 = this->success.begin(); _iter721 != this->success.end(); ++_iter721) { - xfer += (*_iter713).write(oprot); + xfer += (*_iter721).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size714; - ::apache::thrift::protocol::TType _etype717; - xfer += iprot->readListBegin(_etype717, _size714); - (*(this->success)).resize(_size714); - uint32_t _i718; - for (_i718 = 0; _i718 < _size714; ++_i718) + uint32_t _size722; + ::apache::thrift::protocol::TType _etype725; + xfer += iprot->readListBegin(_etype725, _size722); + (*(this->success)).resize(_size722); + uint32_t _i726; + for (_i726 = 0; _i726 < _size722; ++_i726) { - xfer += (*(this->success))[_i718].read(iprot); + xfer += (*(this->success))[_i726].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size719; - ::apache::thrift::protocol::TType _etype722; - xfer += iprot->readListBegin(_etype722, _size719); - this->success.resize(_size719); - uint32_t _i723; - for (_i723 = 0; _i723 < _size719; ++_i723) + uint32_t _size727; + ::apache::thrift::protocol::TType _etype730; + xfer += iprot->readListBegin(_etype730, _size727); + this->success.resize(_size727); + uint32_t _i731; + for (_i731 = 0; _i731 < _size727; ++_i731) { - xfer += this->success[_i723].read(iprot); + xfer += this->success[_i731].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter724; - for (_iter724 = this->success.begin(); _iter724 != this->success.end(); ++_iter724) + std::vector ::const_iterator _iter732; + for (_iter732 = this->success.begin(); _iter732 != this->success.end(); ++_iter732) { - xfer += (*_iter724).write(oprot); + xfer += (*_iter732).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size725; - ::apache::thrift::protocol::TType _etype728; - xfer += iprot->readListBegin(_etype728, _size725); - (*(this->success)).resize(_size725); - uint32_t _i729; - for (_i729 = 0; _i729 < _size725; ++_i729) + uint32_t _size733; + ::apache::thrift::protocol::TType _etype736; + xfer += iprot->readListBegin(_etype736, _size733); + (*(this->success)).resize(_size733); + uint32_t _i737; + for (_i737 = 0; _i737 < _size733; ++_i737) { - xfer += (*(this->success))[_i729].read(iprot); + xfer += (*(this->success))[_i737].read(iprot); } xfer += iprot->readListEnd(); } @@ -5099,14 +5099,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size730; - ::apache::thrift::protocol::TType _etype733; - xfer += iprot->readListBegin(_etype733, _size730); - this->success.resize(_size730); - uint32_t _i734; - for (_i734 = 0; _i734 < _size730; ++_i734) + uint32_t _size738; + ::apache::thrift::protocol::TType _etype741; + xfer += iprot->readListBegin(_etype741, _size738); + this->success.resize(_size738); + uint32_t _i742; + for (_i742 = 0; _i742 < _size738; ++_i742) { - xfer += iprot->readString(this->success[_i734]); + xfer += iprot->readString(this->success[_i742]); } xfer += iprot->readListEnd(); } @@ -5145,10 +5145,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter735; - for (_iter735 = this->success.begin(); _iter735 != this->success.end(); ++_iter735) + std::vector ::const_iterator _iter743; + for (_iter743 = this->success.begin(); _iter743 != this->success.end(); ++_iter743) { - xfer += oprot->writeString((*_iter735)); + xfer += oprot->writeString((*_iter743)); } xfer += oprot->writeListEnd(); } @@ -5193,14 +5193,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size736; - ::apache::thrift::protocol::TType _etype739; - xfer += iprot->readListBegin(_etype739, _size736); - (*(this->success)).resize(_size736); - uint32_t _i740; - for (_i740 = 0; _i740 < _size736; ++_i740) + uint32_t _size744; + ::apache::thrift::protocol::TType _etype747; + xfer += iprot->readListBegin(_etype747, _size744); + (*(this->success)).resize(_size744); + uint32_t _i748; + for (_i748 = 0; _i748 < _size744; ++_i748) { - xfer += iprot->readString((*(this->success))[_i740]); + xfer += iprot->readString((*(this->success))[_i748]); } xfer += iprot->readListEnd(); } @@ -5338,14 +5338,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size741; - ::apache::thrift::protocol::TType _etype744; - xfer += iprot->readListBegin(_etype744, _size741); - this->success.resize(_size741); - uint32_t _i745; - for (_i745 = 0; _i745 < _size741; ++_i745) + uint32_t _size749; + ::apache::thrift::protocol::TType _etype752; + xfer += iprot->readListBegin(_etype752, _size749); + this->success.resize(_size749); + uint32_t _i753; + for (_i753 = 0; _i753 < _size749; ++_i753) { - xfer += iprot->readString(this->success[_i745]); + xfer += iprot->readString(this->success[_i753]); } xfer += iprot->readListEnd(); } @@ -5384,10 +5384,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter746; - for (_iter746 = this->success.begin(); _iter746 != this->success.end(); ++_iter746) + std::vector ::const_iterator _iter754; + for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) { - xfer += oprot->writeString((*_iter746)); + xfer += oprot->writeString((*_iter754)); } xfer += oprot->writeListEnd(); } @@ -5432,14 +5432,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size747; - ::apache::thrift::protocol::TType _etype750; - xfer += iprot->readListBegin(_etype750, _size747); - (*(this->success)).resize(_size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + uint32_t _size755; + ::apache::thrift::protocol::TType _etype758; + xfer += iprot->readListBegin(_etype758, _size755); + (*(this->success)).resize(_size755); + uint32_t _i759; + for (_i759 = 0; _i759 < _size755; ++_i759) { - xfer += iprot->readString((*(this->success))[_i751]); + xfer += iprot->readString((*(this->success))[_i759]); } xfer += iprot->readListEnd(); } @@ -5749,14 +5749,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size752; - ::apache::thrift::protocol::TType _etype755; - xfer += iprot->readListBegin(_etype755, _size752); - this->tbl_names.resize(_size752); - uint32_t _i756; - for (_i756 = 0; _i756 < _size752; ++_i756) + uint32_t _size760; + ::apache::thrift::protocol::TType _etype763; + xfer += iprot->readListBegin(_etype763, _size760); + this->tbl_names.resize(_size760); + uint32_t _i764; + for (_i764 = 0; _i764 < _size760; ++_i764) { - xfer += iprot->readString(this->tbl_names[_i756]); + xfer += iprot->readString(this->tbl_names[_i764]); } xfer += iprot->readListEnd(); } @@ -5789,10 +5789,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->tbl_names.size())); - std::vector ::const_iterator _iter757; - for (_iter757 = this->tbl_names.begin(); _iter757 != this->tbl_names.end(); ++_iter757) + std::vector ::const_iterator _iter765; + for (_iter765 = this->tbl_names.begin(); _iter765 != this->tbl_names.end(); ++_iter765) { - xfer += oprot->writeString((*_iter757)); + xfer += oprot->writeString((*_iter765)); } xfer += oprot->writeListEnd(); } @@ -5820,10 +5820,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter758; - for (_iter758 = (*(this->tbl_names)).begin(); _iter758 != (*(this->tbl_names)).end(); ++_iter758) + std::vector ::const_iterator _iter766; + for (_iter766 = (*(this->tbl_names)).begin(); _iter766 != (*(this->tbl_names)).end(); ++_iter766) { - xfer += oprot->writeString((*_iter758)); + xfer += oprot->writeString((*_iter766)); } xfer += oprot->writeListEnd(); } @@ -5864,14 +5864,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size759; - ::apache::thrift::protocol::TType _etype762; - xfer += iprot->readListBegin(_etype762, _size759); - this->success.resize(_size759); - uint32_t _i763; - for (_i763 = 0; _i763 < _size759; ++_i763) + uint32_t _size767; + ::apache::thrift::protocol::TType _etype770; + xfer += iprot->readListBegin(_etype770, _size767); + this->success.resize(_size767); + uint32_t _i771; + for (_i771 = 0; _i771 < _size767; ++_i771) { - xfer += this->success[_i763].read(iprot); + xfer += this->success[_i771].read(iprot); } xfer += iprot->readListEnd(); } @@ -5926,10 +5926,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter764; - for (_iter764 = this->success.begin(); _iter764 != this->success.end(); ++_iter764) + std::vector
::const_iterator _iter772; + for (_iter772 = this->success.begin(); _iter772 != this->success.end(); ++_iter772) { - xfer += (*_iter764).write(oprot); + xfer += (*_iter772).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5982,14 +5982,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size765; - ::apache::thrift::protocol::TType _etype768; - xfer += iprot->readListBegin(_etype768, _size765); - (*(this->success)).resize(_size765); - uint32_t _i769; - for (_i769 = 0; _i769 < _size765; ++_i769) + uint32_t _size773; + ::apache::thrift::protocol::TType _etype776; + xfer += iprot->readListBegin(_etype776, _size773); + (*(this->success)).resize(_size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - xfer += (*(this->success))[_i769].read(iprot); + xfer += (*(this->success))[_i777].read(iprot); } xfer += iprot->readListEnd(); } @@ -6175,14 +6175,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size770; - ::apache::thrift::protocol::TType _etype773; - xfer += iprot->readListBegin(_etype773, _size770); - this->success.resize(_size770); - uint32_t _i774; - for (_i774 = 0; _i774 < _size770; ++_i774) + uint32_t _size778; + ::apache::thrift::protocol::TType _etype781; + xfer += iprot->readListBegin(_etype781, _size778); + this->success.resize(_size778); + uint32_t _i782; + for (_i782 = 0; _i782 < _size778; ++_i782) { - xfer += iprot->readString(this->success[_i774]); + xfer += iprot->readString(this->success[_i782]); } xfer += iprot->readListEnd(); } @@ -6237,10 +6237,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter775; - for (_iter775 = this->success.begin(); _iter775 != this->success.end(); ++_iter775) + std::vector ::const_iterator _iter783; + for (_iter783 = this->success.begin(); _iter783 != this->success.end(); ++_iter783) { - xfer += oprot->writeString((*_iter775)); + xfer += oprot->writeString((*_iter783)); } xfer += oprot->writeListEnd(); } @@ -6293,14 +6293,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size776; - ::apache::thrift::protocol::TType _etype779; - xfer += iprot->readListBegin(_etype779, _size776); - (*(this->success)).resize(_size776); - uint32_t _i780; - for (_i780 = 0; _i780 < _size776; ++_i780) + uint32_t _size784; + ::apache::thrift::protocol::TType _etype787; + xfer += iprot->readListBegin(_etype787, _size784); + (*(this->success)).resize(_size784); + uint32_t _i788; + for (_i788 = 0; _i788 < _size784; ++_i788) { - xfer += iprot->readString((*(this->success))[_i780]); + xfer += iprot->readString((*(this->success))[_i788]); } xfer += iprot->readListEnd(); } @@ -7634,14 +7634,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size781; - ::apache::thrift::protocol::TType _etype784; - xfer += iprot->readListBegin(_etype784, _size781); - this->new_parts.resize(_size781); - uint32_t _i785; - for (_i785 = 0; _i785 < _size781; ++_i785) + uint32_t _size789; + ::apache::thrift::protocol::TType _etype792; + xfer += iprot->readListBegin(_etype792, _size789); + this->new_parts.resize(_size789); + uint32_t _i793; + for (_i793 = 0; _i793 < _size789; ++_i793) { - xfer += this->new_parts[_i785].read(iprot); + xfer += this->new_parts[_i793].read(iprot); } xfer += iprot->readListEnd(); } @@ -7670,10 +7670,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter786; - for (_iter786 = this->new_parts.begin(); _iter786 != this->new_parts.end(); ++_iter786) + std::vector ::const_iterator _iter794; + for (_iter794 = this->new_parts.begin(); _iter794 != this->new_parts.end(); ++_iter794) { - xfer += (*_iter786).write(oprot); + xfer += (*_iter794).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7697,10 +7697,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter787; - for (_iter787 = (*(this->new_parts)).begin(); _iter787 != (*(this->new_parts)).end(); ++_iter787) + std::vector ::const_iterator _iter795; + for (_iter795 = (*(this->new_parts)).begin(); _iter795 != (*(this->new_parts)).end(); ++_iter795) { - xfer += (*_iter787).write(oprot); + xfer += (*_iter795).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7909,14 +7909,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size788; - ::apache::thrift::protocol::TType _etype791; - xfer += iprot->readListBegin(_etype791, _size788); - this->new_parts.resize(_size788); - uint32_t _i792; - for (_i792 = 0; _i792 < _size788; ++_i792) + uint32_t _size796; + ::apache::thrift::protocol::TType _etype799; + xfer += iprot->readListBegin(_etype799, _size796); + this->new_parts.resize(_size796); + uint32_t _i800; + for (_i800 = 0; _i800 < _size796; ++_i800) { - xfer += this->new_parts[_i792].read(iprot); + xfer += this->new_parts[_i800].read(iprot); } xfer += iprot->readListEnd(); } @@ -7945,10 +7945,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter793; - for (_iter793 = this->new_parts.begin(); _iter793 != this->new_parts.end(); ++_iter793) + std::vector ::const_iterator _iter801; + for (_iter801 = this->new_parts.begin(); _iter801 != this->new_parts.end(); ++_iter801) { - xfer += (*_iter793).write(oprot); + xfer += (*_iter801).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7972,10 +7972,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter794; - for (_iter794 = (*(this->new_parts)).begin(); _iter794 != (*(this->new_parts)).end(); ++_iter794) + std::vector ::const_iterator _iter802; + for (_iter802 = (*(this->new_parts)).begin(); _iter802 != (*(this->new_parts)).end(); ++_iter802) { - xfer += (*_iter794).write(oprot); + xfer += (*_iter802).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8200,14 +8200,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size795; - ::apache::thrift::protocol::TType _etype798; - xfer += iprot->readListBegin(_etype798, _size795); - this->part_vals.resize(_size795); - uint32_t _i799; - for (_i799 = 0; _i799 < _size795; ++_i799) + uint32_t _size803; + ::apache::thrift::protocol::TType _etype806; + xfer += iprot->readListBegin(_etype806, _size803); + this->part_vals.resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += iprot->readString(this->part_vals[_i799]); + xfer += iprot->readString(this->part_vals[_i807]); } xfer += iprot->readListEnd(); } @@ -8244,10 +8244,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter800; - for (_iter800 = this->part_vals.begin(); _iter800 != this->part_vals.end(); ++_iter800) + std::vector ::const_iterator _iter808; + for (_iter808 = this->part_vals.begin(); _iter808 != this->part_vals.end(); ++_iter808) { - xfer += oprot->writeString((*_iter800)); + xfer += oprot->writeString((*_iter808)); } xfer += oprot->writeListEnd(); } @@ -8279,10 +8279,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter801; - for (_iter801 = (*(this->part_vals)).begin(); _iter801 != (*(this->part_vals)).end(); ++_iter801) + std::vector ::const_iterator _iter809; + for (_iter809 = (*(this->part_vals)).begin(); _iter809 != (*(this->part_vals)).end(); ++_iter809) { - xfer += oprot->writeString((*_iter801)); + xfer += oprot->writeString((*_iter809)); } xfer += oprot->writeListEnd(); } @@ -8754,14 +8754,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size802; - ::apache::thrift::protocol::TType _etype805; - xfer += iprot->readListBegin(_etype805, _size802); - this->part_vals.resize(_size802); - uint32_t _i806; - for (_i806 = 0; _i806 < _size802; ++_i806) + uint32_t _size810; + ::apache::thrift::protocol::TType _etype813; + xfer += iprot->readListBegin(_etype813, _size810); + this->part_vals.resize(_size810); + uint32_t _i814; + for (_i814 = 0; _i814 < _size810; ++_i814) { - xfer += iprot->readString(this->part_vals[_i806]); + xfer += iprot->readString(this->part_vals[_i814]); } xfer += iprot->readListEnd(); } @@ -8806,10 +8806,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter807; - for (_iter807 = this->part_vals.begin(); _iter807 != this->part_vals.end(); ++_iter807) + std::vector ::const_iterator _iter815; + for (_iter815 = this->part_vals.begin(); _iter815 != this->part_vals.end(); ++_iter815) { - xfer += oprot->writeString((*_iter807)); + xfer += oprot->writeString((*_iter815)); } xfer += oprot->writeListEnd(); } @@ -8845,10 +8845,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter808; - for (_iter808 = (*(this->part_vals)).begin(); _iter808 != (*(this->part_vals)).end(); ++_iter808) + std::vector ::const_iterator _iter816; + for (_iter816 = (*(this->part_vals)).begin(); _iter816 != (*(this->part_vals)).end(); ++_iter816) { - xfer += oprot->writeString((*_iter808)); + xfer += oprot->writeString((*_iter816)); } xfer += oprot->writeListEnd(); } @@ -9651,14 +9651,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size809; - ::apache::thrift::protocol::TType _etype812; - xfer += iprot->readListBegin(_etype812, _size809); - this->part_vals.resize(_size809); - uint32_t _i813; - for (_i813 = 0; _i813 < _size809; ++_i813) + uint32_t _size817; + ::apache::thrift::protocol::TType _etype820; + xfer += iprot->readListBegin(_etype820, _size817); + this->part_vals.resize(_size817); + uint32_t _i821; + for (_i821 = 0; _i821 < _size817; ++_i821) { - xfer += iprot->readString(this->part_vals[_i813]); + xfer += iprot->readString(this->part_vals[_i821]); } xfer += iprot->readListEnd(); } @@ -9703,10 +9703,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter814; - for (_iter814 = this->part_vals.begin(); _iter814 != this->part_vals.end(); ++_iter814) + std::vector ::const_iterator _iter822; + for (_iter822 = this->part_vals.begin(); _iter822 != this->part_vals.end(); ++_iter822) { - xfer += oprot->writeString((*_iter814)); + xfer += oprot->writeString((*_iter822)); } xfer += oprot->writeListEnd(); } @@ -9742,10 +9742,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter815; - for (_iter815 = (*(this->part_vals)).begin(); _iter815 != (*(this->part_vals)).end(); ++_iter815) + std::vector ::const_iterator _iter823; + for (_iter823 = (*(this->part_vals)).begin(); _iter823 != (*(this->part_vals)).end(); ++_iter823) { - xfer += oprot->writeString((*_iter815)); + xfer += oprot->writeString((*_iter823)); } xfer += oprot->writeListEnd(); } @@ -9954,14 +9954,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size816; - ::apache::thrift::protocol::TType _etype819; - xfer += iprot->readListBegin(_etype819, _size816); - this->part_vals.resize(_size816); - uint32_t _i820; - for (_i820 = 0; _i820 < _size816; ++_i820) + uint32_t _size824; + ::apache::thrift::protocol::TType _etype827; + xfer += iprot->readListBegin(_etype827, _size824); + this->part_vals.resize(_size824); + uint32_t _i828; + for (_i828 = 0; _i828 < _size824; ++_i828) { - xfer += iprot->readString(this->part_vals[_i820]); + xfer += iprot->readString(this->part_vals[_i828]); } xfer += iprot->readListEnd(); } @@ -10014,10 +10014,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter821; - for (_iter821 = this->part_vals.begin(); _iter821 != this->part_vals.end(); ++_iter821) + std::vector ::const_iterator _iter829; + for (_iter829 = this->part_vals.begin(); _iter829 != this->part_vals.end(); ++_iter829) { - xfer += oprot->writeString((*_iter821)); + xfer += oprot->writeString((*_iter829)); } xfer += oprot->writeListEnd(); } @@ -10057,10 +10057,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter822; - for (_iter822 = (*(this->part_vals)).begin(); _iter822 != (*(this->part_vals)).end(); ++_iter822) + std::vector ::const_iterator _iter830; + for (_iter830 = (*(this->part_vals)).begin(); _iter830 != (*(this->part_vals)).end(); ++_iter830) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter830)); } xfer += oprot->writeListEnd(); } @@ -11066,14 +11066,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size823; - ::apache::thrift::protocol::TType _etype826; - xfer += iprot->readListBegin(_etype826, _size823); - this->part_vals.resize(_size823); - uint32_t _i827; - for (_i827 = 0; _i827 < _size823; ++_i827) + uint32_t _size831; + ::apache::thrift::protocol::TType _etype834; + xfer += iprot->readListBegin(_etype834, _size831); + this->part_vals.resize(_size831); + uint32_t _i835; + for (_i835 = 0; _i835 < _size831; ++_i835) { - xfer += iprot->readString(this->part_vals[_i827]); + xfer += iprot->readString(this->part_vals[_i835]); } xfer += iprot->readListEnd(); } @@ -11110,10 +11110,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter828; - for (_iter828 = this->part_vals.begin(); _iter828 != this->part_vals.end(); ++_iter828) + std::vector ::const_iterator _iter836; + for (_iter836 = this->part_vals.begin(); _iter836 != this->part_vals.end(); ++_iter836) { - xfer += oprot->writeString((*_iter828)); + xfer += oprot->writeString((*_iter836)); } xfer += oprot->writeListEnd(); } @@ -11145,10 +11145,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter829; - for (_iter829 = (*(this->part_vals)).begin(); _iter829 != (*(this->part_vals)).end(); ++_iter829) + std::vector ::const_iterator _iter837; + for (_iter837 = (*(this->part_vals)).begin(); _iter837 != (*(this->part_vals)).end(); ++_iter837) { - xfer += oprot->writeString((*_iter829)); + xfer += oprot->writeString((*_iter837)); } xfer += oprot->writeListEnd(); } @@ -11337,17 +11337,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size830; - ::apache::thrift::protocol::TType _ktype831; - ::apache::thrift::protocol::TType _vtype832; - xfer += iprot->readMapBegin(_ktype831, _vtype832, _size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size838; + ::apache::thrift::protocol::TType _ktype839; + ::apache::thrift::protocol::TType _vtype840; + xfer += iprot->readMapBegin(_ktype839, _vtype840, _size838); + uint32_t _i842; + for (_i842 = 0; _i842 < _size838; ++_i842) { - std::string _key835; - xfer += iprot->readString(_key835); - std::string& _val836 = this->partitionSpecs[_key835]; - xfer += iprot->readString(_val836); + std::string _key843; + xfer += iprot->readString(_key843); + std::string& _val844 = this->partitionSpecs[_key843]; + xfer += iprot->readString(_val844); } xfer += iprot->readMapEnd(); } @@ -11408,11 +11408,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter837; - for (_iter837 = this->partitionSpecs.begin(); _iter837 != this->partitionSpecs.end(); ++_iter837) + std::map ::const_iterator _iter845; + for (_iter845 = this->partitionSpecs.begin(); _iter845 != this->partitionSpecs.end(); ++_iter845) { - xfer += oprot->writeString(_iter837->first); - xfer += oprot->writeString(_iter837->second); + xfer += oprot->writeString(_iter845->first); + xfer += oprot->writeString(_iter845->second); } xfer += oprot->writeMapEnd(); } @@ -11452,11 +11452,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter838; - for (_iter838 = (*(this->partitionSpecs)).begin(); _iter838 != (*(this->partitionSpecs)).end(); ++_iter838) + std::map ::const_iterator _iter846; + for (_iter846 = (*(this->partitionSpecs)).begin(); _iter846 != (*(this->partitionSpecs)).end(); ++_iter846) { - xfer += oprot->writeString(_iter838->first); - xfer += oprot->writeString(_iter838->second); + xfer += oprot->writeString(_iter846->first); + xfer += oprot->writeString(_iter846->second); } xfer += oprot->writeMapEnd(); } @@ -11701,17 +11701,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size839; - ::apache::thrift::protocol::TType _ktype840; - ::apache::thrift::protocol::TType _vtype841; - xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839); - uint32_t _i843; - for (_i843 = 0; _i843 < _size839; ++_i843) + uint32_t _size847; + ::apache::thrift::protocol::TType _ktype848; + ::apache::thrift::protocol::TType _vtype849; + xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); + uint32_t _i851; + for (_i851 = 0; _i851 < _size847; ++_i851) { - std::string _key844; - xfer += iprot->readString(_key844); - std::string& _val845 = this->partitionSpecs[_key844]; - xfer += iprot->readString(_val845); + std::string _key852; + xfer += iprot->readString(_key852); + std::string& _val853 = this->partitionSpecs[_key852]; + xfer += iprot->readString(_val853); } xfer += iprot->readMapEnd(); } @@ -11772,11 +11772,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->partitionSpecs.size())); - std::map ::const_iterator _iter846; - for (_iter846 = this->partitionSpecs.begin(); _iter846 != this->partitionSpecs.end(); ++_iter846) + std::map ::const_iterator _iter854; + for (_iter854 = this->partitionSpecs.begin(); _iter854 != this->partitionSpecs.end(); ++_iter854) { - xfer += oprot->writeString(_iter846->first); - xfer += oprot->writeString(_iter846->second); + xfer += oprot->writeString(_iter854->first); + xfer += oprot->writeString(_iter854->second); } xfer += oprot->writeMapEnd(); } @@ -11816,11 +11816,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter847; - for (_iter847 = (*(this->partitionSpecs)).begin(); _iter847 != (*(this->partitionSpecs)).end(); ++_iter847) + std::map ::const_iterator _iter855; + for (_iter855 = (*(this->partitionSpecs)).begin(); _iter855 != (*(this->partitionSpecs)).end(); ++_iter855) { - xfer += oprot->writeString(_iter847->first); - xfer += oprot->writeString(_iter847->second); + xfer += oprot->writeString(_iter855->first); + xfer += oprot->writeString(_iter855->second); } xfer += oprot->writeMapEnd(); } @@ -11877,14 +11877,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size848; - ::apache::thrift::protocol::TType _etype851; - xfer += iprot->readListBegin(_etype851, _size848); - this->success.resize(_size848); - uint32_t _i852; - for (_i852 = 0; _i852 < _size848; ++_i852) + uint32_t _size856; + ::apache::thrift::protocol::TType _etype859; + xfer += iprot->readListBegin(_etype859, _size856); + this->success.resize(_size856); + uint32_t _i860; + for (_i860 = 0; _i860 < _size856; ++_i860) { - xfer += this->success[_i852].read(iprot); + xfer += this->success[_i860].read(iprot); } xfer += iprot->readListEnd(); } @@ -11947,10 +11947,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter853; - for (_iter853 = this->success.begin(); _iter853 != this->success.end(); ++_iter853) + std::vector ::const_iterator _iter861; + for (_iter861 = this->success.begin(); _iter861 != this->success.end(); ++_iter861) { - xfer += (*_iter853).write(oprot); + xfer += (*_iter861).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12007,14 +12007,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size854; - ::apache::thrift::protocol::TType _etype857; - xfer += iprot->readListBegin(_etype857, _size854); - (*(this->success)).resize(_size854); - uint32_t _i858; - for (_i858 = 0; _i858 < _size854; ++_i858) + uint32_t _size862; + ::apache::thrift::protocol::TType _etype865; + xfer += iprot->readListBegin(_etype865, _size862); + (*(this->success)).resize(_size862); + uint32_t _i866; + for (_i866 = 0; _i866 < _size862; ++_i866) { - xfer += (*(this->success))[_i858].read(iprot); + xfer += (*(this->success))[_i866].read(iprot); } xfer += iprot->readListEnd(); } @@ -12113,14 +12113,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size859; - ::apache::thrift::protocol::TType _etype862; - xfer += iprot->readListBegin(_etype862, _size859); - this->part_vals.resize(_size859); - uint32_t _i863; - for (_i863 = 0; _i863 < _size859; ++_i863) + uint32_t _size867; + ::apache::thrift::protocol::TType _etype870; + xfer += iprot->readListBegin(_etype870, _size867); + this->part_vals.resize(_size867); + uint32_t _i871; + for (_i871 = 0; _i871 < _size867; ++_i871) { - xfer += iprot->readString(this->part_vals[_i863]); + xfer += iprot->readString(this->part_vals[_i871]); } xfer += iprot->readListEnd(); } @@ -12141,14 +12141,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size864; - ::apache::thrift::protocol::TType _etype867; - xfer += iprot->readListBegin(_etype867, _size864); - this->group_names.resize(_size864); - uint32_t _i868; - for (_i868 = 0; _i868 < _size864; ++_i868) + uint32_t _size872; + ::apache::thrift::protocol::TType _etype875; + xfer += iprot->readListBegin(_etype875, _size872); + this->group_names.resize(_size872); + uint32_t _i876; + for (_i876 = 0; _i876 < _size872; ++_i876) { - xfer += iprot->readString(this->group_names[_i868]); + xfer += iprot->readString(this->group_names[_i876]); } xfer += iprot->readListEnd(); } @@ -12185,10 +12185,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter869; - for (_iter869 = this->part_vals.begin(); _iter869 != this->part_vals.end(); ++_iter869) + std::vector ::const_iterator _iter877; + for (_iter877 = this->part_vals.begin(); _iter877 != this->part_vals.end(); ++_iter877) { - xfer += oprot->writeString((*_iter869)); + xfer += oprot->writeString((*_iter877)); } xfer += oprot->writeListEnd(); } @@ -12201,10 +12201,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter870; - for (_iter870 = this->group_names.begin(); _iter870 != this->group_names.end(); ++_iter870) + std::vector ::const_iterator _iter878; + for (_iter878 = this->group_names.begin(); _iter878 != this->group_names.end(); ++_iter878) { - xfer += oprot->writeString((*_iter870)); + xfer += oprot->writeString((*_iter878)); } xfer += oprot->writeListEnd(); } @@ -12236,10 +12236,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter871; - for (_iter871 = (*(this->part_vals)).begin(); _iter871 != (*(this->part_vals)).end(); ++_iter871) + std::vector ::const_iterator _iter879; + for (_iter879 = (*(this->part_vals)).begin(); _iter879 != (*(this->part_vals)).end(); ++_iter879) { - xfer += oprot->writeString((*_iter871)); + xfer += oprot->writeString((*_iter879)); } xfer += oprot->writeListEnd(); } @@ -12252,10 +12252,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter872; - for (_iter872 = (*(this->group_names)).begin(); _iter872 != (*(this->group_names)).end(); ++_iter872) + std::vector ::const_iterator _iter880; + for (_iter880 = (*(this->group_names)).begin(); _iter880 != (*(this->group_names)).end(); ++_iter880) { - xfer += oprot->writeString((*_iter872)); + xfer += oprot->writeString((*_iter880)); } xfer += oprot->writeListEnd(); } @@ -12814,14 +12814,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size873; - ::apache::thrift::protocol::TType _etype876; - xfer += iprot->readListBegin(_etype876, _size873); - this->success.resize(_size873); - uint32_t _i877; - for (_i877 = 0; _i877 < _size873; ++_i877) + uint32_t _size881; + ::apache::thrift::protocol::TType _etype884; + xfer += iprot->readListBegin(_etype884, _size881); + this->success.resize(_size881); + uint32_t _i885; + for (_i885 = 0; _i885 < _size881; ++_i885) { - xfer += this->success[_i877].read(iprot); + xfer += this->success[_i885].read(iprot); } xfer += iprot->readListEnd(); } @@ -12868,10 +12868,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter878; - for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) + std::vector ::const_iterator _iter886; + for (_iter886 = this->success.begin(); _iter886 != this->success.end(); ++_iter886) { - xfer += (*_iter878).write(oprot); + xfer += (*_iter886).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12920,14 +12920,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size879; - ::apache::thrift::protocol::TType _etype882; - xfer += iprot->readListBegin(_etype882, _size879); - (*(this->success)).resize(_size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + (*(this->success)).resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += (*(this->success))[_i883].read(iprot); + xfer += (*(this->success))[_i891].read(iprot); } xfer += iprot->readListEnd(); } @@ -13026,14 +13026,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size884; - ::apache::thrift::protocol::TType _etype887; - xfer += iprot->readListBegin(_etype887, _size884); - this->group_names.resize(_size884); - uint32_t _i888; - for (_i888 = 0; _i888 < _size884; ++_i888) + uint32_t _size892; + ::apache::thrift::protocol::TType _etype895; + xfer += iprot->readListBegin(_etype895, _size892); + this->group_names.resize(_size892); + uint32_t _i896; + for (_i896 = 0; _i896 < _size892; ++_i896) { - xfer += iprot->readString(this->group_names[_i888]); + xfer += iprot->readString(this->group_names[_i896]); } xfer += iprot->readListEnd(); } @@ -13078,10 +13078,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter889; - for (_iter889 = this->group_names.begin(); _iter889 != this->group_names.end(); ++_iter889) + std::vector ::const_iterator _iter897; + for (_iter897 = this->group_names.begin(); _iter897 != this->group_names.end(); ++_iter897) { - xfer += oprot->writeString((*_iter889)); + xfer += oprot->writeString((*_iter897)); } xfer += oprot->writeListEnd(); } @@ -13121,10 +13121,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter890; - for (_iter890 = (*(this->group_names)).begin(); _iter890 != (*(this->group_names)).end(); ++_iter890) + std::vector ::const_iterator _iter898; + for (_iter898 = (*(this->group_names)).begin(); _iter898 != (*(this->group_names)).end(); ++_iter898) { - xfer += oprot->writeString((*_iter890)); + xfer += oprot->writeString((*_iter898)); } xfer += oprot->writeListEnd(); } @@ -13165,14 +13165,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size891; - ::apache::thrift::protocol::TType _etype894; - xfer += iprot->readListBegin(_etype894, _size891); - this->success.resize(_size891); - uint32_t _i895; - for (_i895 = 0; _i895 < _size891; ++_i895) + uint32_t _size899; + ::apache::thrift::protocol::TType _etype902; + xfer += iprot->readListBegin(_etype902, _size899); + this->success.resize(_size899); + uint32_t _i903; + for (_i903 = 0; _i903 < _size899; ++_i903) { - xfer += this->success[_i895].read(iprot); + xfer += this->success[_i903].read(iprot); } xfer += iprot->readListEnd(); } @@ -13219,10 +13219,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter896; - for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) + std::vector ::const_iterator _iter904; + for (_iter904 = this->success.begin(); _iter904 != this->success.end(); ++_iter904) { - xfer += (*_iter896).write(oprot); + xfer += (*_iter904).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13271,14 +13271,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size897; - ::apache::thrift::protocol::TType _etype900; - xfer += iprot->readListBegin(_etype900, _size897); - (*(this->success)).resize(_size897); - uint32_t _i901; - for (_i901 = 0; _i901 < _size897; ++_i901) + uint32_t _size905; + ::apache::thrift::protocol::TType _etype908; + xfer += iprot->readListBegin(_etype908, _size905); + (*(this->success)).resize(_size905); + uint32_t _i909; + for (_i909 = 0; _i909 < _size905; ++_i909) { - xfer += (*(this->success))[_i901].read(iprot); + xfer += (*(this->success))[_i909].read(iprot); } xfer += iprot->readListEnd(); } @@ -13456,14 +13456,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size902; - ::apache::thrift::protocol::TType _etype905; - xfer += iprot->readListBegin(_etype905, _size902); - this->success.resize(_size902); - uint32_t _i906; - for (_i906 = 0; _i906 < _size902; ++_i906) + uint32_t _size910; + ::apache::thrift::protocol::TType _etype913; + xfer += iprot->readListBegin(_etype913, _size910); + this->success.resize(_size910); + uint32_t _i914; + for (_i914 = 0; _i914 < _size910; ++_i914) { - xfer += this->success[_i906].read(iprot); + xfer += this->success[_i914].read(iprot); } xfer += iprot->readListEnd(); } @@ -13510,10 +13510,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter907; - for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907) + std::vector ::const_iterator _iter915; + for (_iter915 = this->success.begin(); _iter915 != this->success.end(); ++_iter915) { - xfer += (*_iter907).write(oprot); + xfer += (*_iter915).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13562,14 +13562,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size908; - ::apache::thrift::protocol::TType _etype911; - xfer += iprot->readListBegin(_etype911, _size908); - (*(this->success)).resize(_size908); - uint32_t _i912; - for (_i912 = 0; _i912 < _size908; ++_i912) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + (*(this->success)).resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += (*(this->success))[_i912].read(iprot); + xfer += (*(this->success))[_i920].read(iprot); } xfer += iprot->readListEnd(); } @@ -13747,14 +13747,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->success.resize(_size913); - uint32_t _i917; - for (_i917 = 0; _i917 < _size913; ++_i917) + uint32_t _size921; + ::apache::thrift::protocol::TType _etype924; + xfer += iprot->readListBegin(_etype924, _size921); + this->success.resize(_size921); + uint32_t _i925; + for (_i925 = 0; _i925 < _size921; ++_i925) { - xfer += iprot->readString(this->success[_i917]); + xfer += iprot->readString(this->success[_i925]); } xfer += iprot->readListEnd(); } @@ -13793,10 +13793,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector ::const_iterator _iter926; + for (_iter926 = this->success.begin(); _iter926 != this->success.end(); ++_iter926) { - xfer += oprot->writeString((*_iter918)); + xfer += oprot->writeString((*_iter926)); } xfer += oprot->writeListEnd(); } @@ -13841,14 +13841,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size927; + ::apache::thrift::protocol::TType _etype930; + xfer += iprot->readListBegin(_etype930, _size927); + (*(this->success)).resize(_size927); + uint32_t _i931; + for (_i931 = 0; _i931 < _size927; ++_i931) { - xfer += iprot->readString((*(this->success))[_i923]); + xfer += iprot->readString((*(this->success))[_i931]); } xfer += iprot->readListEnd(); } @@ -13923,14 +13923,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - this->part_vals.resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + this->part_vals.resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += iprot->readString(this->part_vals[_i928]); + xfer += iprot->readString(this->part_vals[_i936]); } xfer += iprot->readListEnd(); } @@ -13975,10 +13975,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter929; - for (_iter929 = this->part_vals.begin(); _iter929 != this->part_vals.end(); ++_iter929) + std::vector ::const_iterator _iter937; + for (_iter937 = this->part_vals.begin(); _iter937 != this->part_vals.end(); ++_iter937) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter937)); } xfer += oprot->writeListEnd(); } @@ -14014,10 +14014,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter930; - for (_iter930 = (*(this->part_vals)).begin(); _iter930 != (*(this->part_vals)).end(); ++_iter930) + std::vector ::const_iterator _iter938; + for (_iter938 = (*(this->part_vals)).begin(); _iter938 != (*(this->part_vals)).end(); ++_iter938) { - xfer += oprot->writeString((*_iter930)); + xfer += oprot->writeString((*_iter938)); } xfer += oprot->writeListEnd(); } @@ -14062,14 +14062,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size931; - ::apache::thrift::protocol::TType _etype934; - xfer += iprot->readListBegin(_etype934, _size931); - this->success.resize(_size931); - uint32_t _i935; - for (_i935 = 0; _i935 < _size931; ++_i935) + uint32_t _size939; + ::apache::thrift::protocol::TType _etype942; + xfer += iprot->readListBegin(_etype942, _size939); + this->success.resize(_size939); + uint32_t _i943; + for (_i943 = 0; _i943 < _size939; ++_i943) { - xfer += this->success[_i935].read(iprot); + xfer += this->success[_i943].read(iprot); } xfer += iprot->readListEnd(); } @@ -14116,10 +14116,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter936; - for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936) + std::vector ::const_iterator _iter944; + for (_iter944 = this->success.begin(); _iter944 != this->success.end(); ++_iter944) { - xfer += (*_iter936).write(oprot); + xfer += (*_iter944).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14168,14 +14168,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size937; - ::apache::thrift::protocol::TType _etype940; - xfer += iprot->readListBegin(_etype940, _size937); - (*(this->success)).resize(_size937); - uint32_t _i941; - for (_i941 = 0; _i941 < _size937; ++_i941) + uint32_t _size945; + ::apache::thrift::protocol::TType _etype948; + xfer += iprot->readListBegin(_etype948, _size945); + (*(this->success)).resize(_size945); + uint32_t _i949; + for (_i949 = 0; _i949 < _size945; ++_i949) { - xfer += (*(this->success))[_i941].read(iprot); + xfer += (*(this->success))[_i949].read(iprot); } xfer += iprot->readListEnd(); } @@ -14258,14 +14258,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->part_vals.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size950; + ::apache::thrift::protocol::TType _etype953; + xfer += iprot->readListBegin(_etype953, _size950); + this->part_vals.resize(_size950); + uint32_t _i954; + for (_i954 = 0; _i954 < _size950; ++_i954) { - xfer += iprot->readString(this->part_vals[_i946]); + xfer += iprot->readString(this->part_vals[_i954]); } xfer += iprot->readListEnd(); } @@ -14294,14 +14294,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size947; - ::apache::thrift::protocol::TType _etype950; - xfer += iprot->readListBegin(_etype950, _size947); - this->group_names.resize(_size947); - uint32_t _i951; - for (_i951 = 0; _i951 < _size947; ++_i951) + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + this->group_names.resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) { - xfer += iprot->readString(this->group_names[_i951]); + xfer += iprot->readString(this->group_names[_i959]); } xfer += iprot->readListEnd(); } @@ -14338,10 +14338,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter952; - for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952) + std::vector ::const_iterator _iter960; + for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) { - xfer += oprot->writeString((*_iter952)); + xfer += oprot->writeString((*_iter960)); } xfer += oprot->writeListEnd(); } @@ -14358,10 +14358,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter953; - for (_iter953 = this->group_names.begin(); _iter953 != this->group_names.end(); ++_iter953) + std::vector ::const_iterator _iter961; + for (_iter961 = this->group_names.begin(); _iter961 != this->group_names.end(); ++_iter961) { - xfer += oprot->writeString((*_iter953)); + xfer += oprot->writeString((*_iter961)); } xfer += oprot->writeListEnd(); } @@ -14393,10 +14393,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs