http://git-wip-us.apache.org/repos/asf/hive/blob/6c4c6369/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 29d9ec4..0440df7 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 _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(); } @@ -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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter752; - for (_iter752 = this->success.begin(); _iter752 != this->success.end(); ++_iter752) + std::vector<std::string> ::const_iterator _iter760; + for (_iter760 = this->success.begin(); _iter760 != this->success.end(); ++_iter760) { - xfer += oprot->writeString((*_iter752)); + xfer += oprot->writeString((*_iter760)); } 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 _size753; - ::apache::thrift::protocol::TType _etype756; - xfer += iprot->readListBegin(_etype756, _size753); - (*(this->success)).resize(_size753); - uint32_t _i757; - for (_i757 = 0; _i757 < _size753; ++_i757) + uint32_t _size761; + ::apache::thrift::protocol::TType _etype764; + xfer += iprot->readListBegin(_etype764, _size761); + (*(this->success)).resize(_size761); + uint32_t _i765; + for (_i765 = 0; _i765 < _size761; ++_i765) { - xfer += iprot->readString((*(this->success))[_i757]); + xfer += iprot->readString((*(this->success))[_i765]); } 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 _size758; - ::apache::thrift::protocol::TType _etype761; - xfer += iprot->readListBegin(_etype761, _size758); - this->success.resize(_size758); - uint32_t _i762; - for (_i762 = 0; _i762 < _size758; ++_i762) + uint32_t _size766; + ::apache::thrift::protocol::TType _etype769; + xfer += iprot->readListBegin(_etype769, _size766); + this->success.resize(_size766); + uint32_t _i770; + for (_i770 = 0; _i770 < _size766; ++_i770) { - xfer += iprot->readString(this->success[_i762]); + xfer += iprot->readString(this->success[_i770]); } 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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter763; - for (_iter763 = this->success.begin(); _iter763 != this->success.end(); ++_iter763) + std::vector<std::string> ::const_iterator _iter771; + for (_iter771 = this->success.begin(); _iter771 != this->success.end(); ++_iter771) { - xfer += oprot->writeString((*_iter763)); + xfer += oprot->writeString((*_iter771)); } 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 _size764; - ::apache::thrift::protocol::TType _etype767; - xfer += iprot->readListBegin(_etype767, _size764); - (*(this->success)).resize(_size764); - uint32_t _i768; - for (_i768 = 0; _i768 < _size764; ++_i768) + uint32_t _size772; + ::apache::thrift::protocol::TType _etype775; + xfer += iprot->readListBegin(_etype775, _size772); + (*(this->success)).resize(_size772); + uint32_t _i776; + for (_i776 = 0; _i776 < _size772; ++_i776) { - xfer += iprot->readString((*(this->success))[_i768]); + xfer += iprot->readString((*(this->success))[_i776]); } 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 _size769; - ::apache::thrift::protocol::TType _ktype770; - ::apache::thrift::protocol::TType _vtype771; - xfer += iprot->readMapBegin(_ktype770, _vtype771, _size769); - uint32_t _i773; - for (_i773 = 0; _i773 < _size769; ++_i773) + uint32_t _size777; + ::apache::thrift::protocol::TType _ktype778; + ::apache::thrift::protocol::TType _vtype779; + xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777); + uint32_t _i781; + for (_i781 = 0; _i781 < _size777; ++_i781) { - std::string _key774; - xfer += iprot->readString(_key774); - Type& _val775 = this->success[_key774]; - xfer += _val775.read(iprot); + std::string _key782; + xfer += iprot->readString(_key782); + Type& _val783 = this->success[_key782]; + xfer += _val783.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<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter776; - for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776) + std::map<std::string, Type> ::const_iterator _iter784; + for (_iter784 = this->success.begin(); _iter784 != this->success.end(); ++_iter784) { - xfer += oprot->writeString(_iter776->first); - xfer += _iter776->second.write(oprot); + xfer += oprot->writeString(_iter784->first); + xfer += _iter784->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 _size777; - ::apache::thrift::protocol::TType _ktype778; - ::apache::thrift::protocol::TType _vtype779; - xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777); - uint32_t _i781; - for (_i781 = 0; _i781 < _size777; ++_i781) + uint32_t _size785; + ::apache::thrift::protocol::TType _ktype786; + ::apache::thrift::protocol::TType _vtype787; + xfer += iprot->readMapBegin(_ktype786, _vtype787, _size785); + uint32_t _i789; + for (_i789 = 0; _i789 < _size785; ++_i789) { - std::string _key782; - xfer += iprot->readString(_key782); - Type& _val783 = (*(this->success))[_key782]; - xfer += _val783.read(iprot); + std::string _key790; + xfer += iprot->readString(_key790); + Type& _val791 = (*(this->success))[_key790]; + xfer += _val791.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 _size784; - ::apache::thrift::protocol::TType _etype787; - xfer += iprot->readListBegin(_etype787, _size784); - this->success.resize(_size784); - uint32_t _i788; - for (_i788 = 0; _i788 < _size784; ++_i788) + uint32_t _size792; + ::apache::thrift::protocol::TType _etype795; + xfer += iprot->readListBegin(_etype795, _size792); + this->success.resize(_size792); + uint32_t _i796; + for (_i796 = 0; _i796 < _size792; ++_i796) { - xfer += this->success[_i788].read(iprot); + xfer += this->success[_i796].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<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter789; - for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) + std::vector<FieldSchema> ::const_iterator _iter797; + for (_iter797 = this->success.begin(); _iter797 != this->success.end(); ++_iter797) { - xfer += (*_iter789).write(oprot); + xfer += (*_iter797).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 _size790; - ::apache::thrift::protocol::TType _etype793; - xfer += iprot->readListBegin(_etype793, _size790); - (*(this->success)).resize(_size790); - uint32_t _i794; - for (_i794 = 0; _i794 < _size790; ++_i794) + uint32_t _size798; + ::apache::thrift::protocol::TType _etype801; + xfer += iprot->readListBegin(_etype801, _size798); + (*(this->success)).resize(_size798); + uint32_t _i802; + for (_i802 = 0; _i802 < _size798; ++_i802) { - xfer += (*(this->success))[_i794].read(iprot); + xfer += (*(this->success))[_i802].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 _size795; - ::apache::thrift::protocol::TType _etype798; - xfer += iprot->readListBegin(_etype798, _size795); - this->success.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->success.resize(_size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - xfer += this->success[_i799].read(iprot); + xfer += this->success[_i807].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<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter800; - for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) + std::vector<FieldSchema> ::const_iterator _iter808; + for (_iter808 = this->success.begin(); _iter808 != this->success.end(); ++_iter808) { - xfer += (*_iter800).write(oprot); + xfer += (*_iter808).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 _size801; - ::apache::thrift::protocol::TType _etype804; - xfer += iprot->readListBegin(_etype804, _size801); - (*(this->success)).resize(_size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size809; + ::apache::thrift::protocol::TType _etype812; + xfer += iprot->readListBegin(_etype812, _size809); + (*(this->success)).resize(_size809); + uint32_t _i813; + for (_i813 = 0; _i813 < _size809; ++_i813) { - xfer += (*(this->success))[_i805].read(iprot); + xfer += (*(this->success))[_i813].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 _size806; - ::apache::thrift::protocol::TType _etype809; - xfer += iprot->readListBegin(_etype809, _size806); - this->success.resize(_size806); - uint32_t _i810; - for (_i810 = 0; _i810 < _size806; ++_i810) + uint32_t _size814; + ::apache::thrift::protocol::TType _etype817; + xfer += iprot->readListBegin(_etype817, _size814); + this->success.resize(_size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - xfer += this->success[_i810].read(iprot); + xfer += this->success[_i818].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<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter811; - for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811) + std::vector<FieldSchema> ::const_iterator _iter819; + for (_iter819 = this->success.begin(); _iter819 != this->success.end(); ++_iter819) { - xfer += (*_iter811).write(oprot); + xfer += (*_iter819).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 _size812; - ::apache::thrift::protocol::TType _etype815; - xfer += iprot->readListBegin(_etype815, _size812); - (*(this->success)).resize(_size812); - uint32_t _i816; - for (_i816 = 0; _i816 < _size812; ++_i816) + uint32_t _size820; + ::apache::thrift::protocol::TType _etype823; + xfer += iprot->readListBegin(_etype823, _size820); + (*(this->success)).resize(_size820); + uint32_t _i824; + for (_i824 = 0; _i824 < _size820; ++_i824) { - xfer += (*(this->success))[_i816].read(iprot); + xfer += (*(this->success))[_i824].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 _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->success.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + this->success.resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += this->success[_i821].read(iprot); + xfer += this->success[_i829].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<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter822; - for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) + std::vector<FieldSchema> ::const_iterator _iter830; + for (_iter830 = this->success.begin(); _iter830 != this->success.end(); ++_iter830) { - xfer += (*_iter822).write(oprot); + xfer += (*_iter830).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 _size823; - ::apache::thrift::protocol::TType _etype826; - xfer += iprot->readListBegin(_etype826, _size823); - (*(this->success)).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->success)).resize(_size831); + uint32_t _i835; + for (_i835 = 0; _i835 < _size831; ++_i835) { - xfer += (*(this->success))[_i827].read(iprot); + xfer += (*(this->success))[_i835].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size828; - ::apache::thrift::protocol::TType _etype831; - xfer += iprot->readListBegin(_etype831, _size828); - this->primaryKeys.resize(_size828); - uint32_t _i832; - for (_i832 = 0; _i832 < _size828; ++_i832) + uint32_t _size836; + ::apache::thrift::protocol::TType _etype839; + xfer += iprot->readListBegin(_etype839, _size836); + this->primaryKeys.resize(_size836); + uint32_t _i840; + for (_i840 = 0; _i840 < _size836; ++_i840) { - xfer += this->primaryKeys[_i832].read(iprot); + xfer += this->primaryKeys[_i840].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size833; - ::apache::thrift::protocol::TType _etype836; - xfer += iprot->readListBegin(_etype836, _size833); - this->foreignKeys.resize(_size833); - uint32_t _i837; - for (_i837 = 0; _i837 < _size833; ++_i837) + uint32_t _size841; + ::apache::thrift::protocol::TType _etype844; + xfer += iprot->readListBegin(_etype844, _size841); + this->foreignKeys.resize(_size841); + uint32_t _i845; + for (_i845 = 0; _i845 < _size841; ++_i845) { - xfer += this->foreignKeys[_i837].read(iprot); + xfer += this->foreignKeys[_i845].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,10 +4578,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter838; - for (_iter838 = this->primaryKeys.begin(); _iter838 != this->primaryKeys.end(); ++_iter838) + std::vector<SQLPrimaryKey> ::const_iterator _iter846; + for (_iter846 = this->primaryKeys.begin(); _iter846 != this->primaryKeys.end(); ++_iter846) { - xfer += (*_iter838).write(oprot); + xfer += (*_iter846).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4590,10 +4590,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter839; - for (_iter839 = this->foreignKeys.begin(); _iter839 != this->foreignKeys.end(); ++_iter839) + std::vector<SQLForeignKey> ::const_iterator _iter847; + for (_iter847 = this->foreignKeys.begin(); _iter847 != this->foreignKeys.end(); ++_iter847) { - xfer += (*_iter839).write(oprot); + xfer += (*_iter847).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4621,10 +4621,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter840; - for (_iter840 = (*(this->primaryKeys)).begin(); _iter840 != (*(this->primaryKeys)).end(); ++_iter840) + std::vector<SQLPrimaryKey> ::const_iterator _iter848; + for (_iter848 = (*(this->primaryKeys)).begin(); _iter848 != (*(this->primaryKeys)).end(); ++_iter848) { - xfer += (*_iter840).write(oprot); + xfer += (*_iter848).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4633,10 +4633,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size())); - std::vector<SQLForeignKey> ::const_iterator _iter841; - for (_iter841 = (*(this->foreignKeys)).begin(); _iter841 != (*(this->foreignKeys)).end(); ++_iter841) + std::vector<SQLForeignKey> ::const_iterator _iter849; + for (_iter849 = (*(this->foreignKeys)).begin(); _iter849 != (*(this->foreignKeys)).end(); ++_iter849) { - xfer += (*_iter841).write(oprot); + xfer += (*_iter849).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5641,14 +5641,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size842; - ::apache::thrift::protocol::TType _etype845; - xfer += iprot->readListBegin(_etype845, _size842); - this->success.resize(_size842); - uint32_t _i846; - for (_i846 = 0; _i846 < _size842; ++_i846) + uint32_t _size850; + ::apache::thrift::protocol::TType _etype853; + xfer += iprot->readListBegin(_etype853, _size850); + this->success.resize(_size850); + uint32_t _i854; + for (_i854 = 0; _i854 < _size850; ++_i854) { - xfer += iprot->readString(this->success[_i846]); + xfer += iprot->readString(this->success[_i854]); } xfer += iprot->readListEnd(); } @@ -5687,10 +5687,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter847; - for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847) + std::vector<std::string> ::const_iterator _iter855; + for (_iter855 = this->success.begin(); _iter855 != this->success.end(); ++_iter855) { - xfer += oprot->writeString((*_iter847)); + xfer += oprot->writeString((*_iter855)); } xfer += oprot->writeListEnd(); } @@ -5735,14 +5735,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol 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 += iprot->readString((*(this->success))[_i852]); + xfer += iprot->readString((*(this->success))[_i860]); } xfer += iprot->readListEnd(); } @@ -5817,14 +5817,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size853; - ::apache::thrift::protocol::TType _etype856; - xfer += iprot->readListBegin(_etype856, _size853); - this->tbl_types.resize(_size853); - uint32_t _i857; - for (_i857 = 0; _i857 < _size853; ++_i857) + uint32_t _size861; + ::apache::thrift::protocol::TType _etype864; + xfer += iprot->readListBegin(_etype864, _size861); + this->tbl_types.resize(_size861); + uint32_t _i865; + for (_i865 = 0; _i865 < _size861; ++_i865) { - xfer += iprot->readString(this->tbl_types[_i857]); + xfer += iprot->readString(this->tbl_types[_i865]); } xfer += iprot->readListEnd(); } @@ -5861,10 +5861,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size())); - std::vector<std::string> ::const_iterator _iter858; - for (_iter858 = this->tbl_types.begin(); _iter858 != this->tbl_types.end(); ++_iter858) + std::vector<std::string> ::const_iterator _iter866; + for (_iter866 = this->tbl_types.begin(); _iter866 != this->tbl_types.end(); ++_iter866) { - xfer += oprot->writeString((*_iter858)); + xfer += oprot->writeString((*_iter866)); } xfer += oprot->writeListEnd(); } @@ -5896,10 +5896,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size())); - std::vector<std::string> ::const_iterator _iter859; - for (_iter859 = (*(this->tbl_types)).begin(); _iter859 != (*(this->tbl_types)).end(); ++_iter859) + std::vector<std::string> ::const_iterator _iter867; + for (_iter867 = (*(this->tbl_types)).begin(); _iter867 != (*(this->tbl_types)).end(); ++_iter867) { - xfer += oprot->writeString((*_iter859)); + xfer += oprot->writeString((*_iter867)); } xfer += oprot->writeListEnd(); } @@ -5940,14 +5940,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size860; - ::apache::thrift::protocol::TType _etype863; - xfer += iprot->readListBegin(_etype863, _size860); - this->success.resize(_size860); - uint32_t _i864; - for (_i864 = 0; _i864 < _size860; ++_i864) + uint32_t _size868; + ::apache::thrift::protocol::TType _etype871; + xfer += iprot->readListBegin(_etype871, _size868); + this->success.resize(_size868); + uint32_t _i872; + for (_i872 = 0; _i872 < _size868; ++_i872) { - xfer += this->success[_i864].read(iprot); + xfer += this->success[_i872].read(iprot); } xfer += iprot->readListEnd(); } @@ -5986,10 +5986,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_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<uint32_t>(this->success.size())); - std::vector<TableMeta> ::const_iterator _iter865; - for (_iter865 = this->success.begin(); _iter865 != this->success.end(); ++_iter865) + std::vector<TableMeta> ::const_iterator _iter873; + for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) { - xfer += (*_iter865).write(oprot); + xfer += (*_iter873).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6034,14 +6034,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size866; - ::apache::thrift::protocol::TType _etype869; - xfer += iprot->readListBegin(_etype869, _size866); - (*(this->success)).resize(_size866); - uint32_t _i870; - for (_i870 = 0; _i870 < _size866; ++_i870) + uint32_t _size874; + ::apache::thrift::protocol::TType _etype877; + xfer += iprot->readListBegin(_etype877, _size874); + (*(this->success)).resize(_size874); + uint32_t _i878; + for (_i878 = 0; _i878 < _size874; ++_i878) { - xfer += (*(this->success))[_i870].read(iprot); + xfer += (*(this->success))[_i878].read(iprot); } xfer += iprot->readListEnd(); } @@ -6179,14 +6179,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size871; - ::apache::thrift::protocol::TType _etype874; - xfer += iprot->readListBegin(_etype874, _size871); - this->success.resize(_size871); - uint32_t _i875; - for (_i875 = 0; _i875 < _size871; ++_i875) + 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) { - xfer += iprot->readString(this->success[_i875]); + xfer += iprot->readString(this->success[_i883]); } xfer += iprot->readListEnd(); } @@ -6225,10 +6225,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter876; - for (_iter876 = this->success.begin(); _iter876 != this->success.end(); ++_iter876) + std::vector<std::string> ::const_iterator _iter884; + for (_iter884 = this->success.begin(); _iter884 != this->success.end(); ++_iter884) { - xfer += oprot->writeString((*_iter876)); + xfer += oprot->writeString((*_iter884)); } xfer += oprot->writeListEnd(); } @@ -6273,14 +6273,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - (*(this->success)).resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + uint32_t _size885; + ::apache::thrift::protocol::TType _etype888; + xfer += iprot->readListBegin(_etype888, _size885); + (*(this->success)).resize(_size885); + uint32_t _i889; + for (_i889 = 0; _i889 < _size885; ++_i889) { - xfer += iprot->readString((*(this->success))[_i881]); + xfer += iprot->readString((*(this->success))[_i889]); } xfer += iprot->readListEnd(); } @@ -6590,14 +6590,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 _size882; - ::apache::thrift::protocol::TType _etype885; - xfer += iprot->readListBegin(_etype885, _size882); - this->tbl_names.resize(_size882); - uint32_t _i886; - for (_i886 = 0; _i886 < _size882; ++_i886) + uint32_t _size890; + ::apache::thrift::protocol::TType _etype893; + xfer += iprot->readListBegin(_etype893, _size890); + this->tbl_names.resize(_size890); + uint32_t _i894; + for (_i894 = 0; _i894 < _size890; ++_i894) { - xfer += iprot->readString(this->tbl_names[_i886]); + xfer += iprot->readString(this->tbl_names[_i894]); } xfer += iprot->readListEnd(); } @@ -6630,10 +6630,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<uint32_t>(this->tbl_names.size())); - std::vector<std::string> ::const_iterator _iter887; - for (_iter887 = this->tbl_names.begin(); _iter887 != this->tbl_names.end(); ++_iter887) + std::vector<std::string> ::const_iterator _iter895; + for (_iter895 = this->tbl_names.begin(); _iter895 != this->tbl_names.end(); ++_iter895) { - xfer += oprot->writeString((*_iter887)); + xfer += oprot->writeString((*_iter895)); } xfer += oprot->writeListEnd(); } @@ -6661,10 +6661,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<uint32_t>((*(this->tbl_names)).size())); - std::vector<std::string> ::const_iterator _iter888; - for (_iter888 = (*(this->tbl_names)).begin(); _iter888 != (*(this->tbl_names)).end(); ++_iter888) + std::vector<std::string> ::const_iterator _iter896; + for (_iter896 = (*(this->tbl_names)).begin(); _iter896 != (*(this->tbl_names)).end(); ++_iter896) { - xfer += oprot->writeString((*_iter888)); + xfer += oprot->writeString((*_iter896)); } xfer += oprot->writeListEnd(); } @@ -6705,14 +6705,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 _size889; - ::apache::thrift::protocol::TType _etype892; - xfer += iprot->readListBegin(_etype892, _size889); - this->success.resize(_size889); - uint32_t _i893; - for (_i893 = 0; _i893 < _size889; ++_i893) + 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) { - xfer += this->success[_i893].read(iprot); + xfer += this->success[_i901].read(iprot); } xfer += iprot->readListEnd(); } @@ -6767,10 +6767,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<uint32_t>(this->success.size())); - std::vector<Table> ::const_iterator _iter894; - for (_iter894 = this->success.begin(); _iter894 != this->success.end(); ++_iter894) + std::vector<Table> ::const_iterator _iter902; + for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) { - xfer += (*_iter894).write(oprot); + xfer += (*_iter902).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6823,14 +6823,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 _size895; - ::apache::thrift::protocol::TType _etype898; - xfer += iprot->readListBegin(_etype898, _size895); - (*(this->success)).resize(_size895); - uint32_t _i899; - for (_i899 = 0; _i899 < _size895; ++_i899) + uint32_t _size903; + ::apache::thrift::protocol::TType _etype906; + xfer += iprot->readListBegin(_etype906, _size903); + (*(this->success)).resize(_size903); + uint32_t _i907; + for (_i907 = 0; _i907 < _size903; ++_i907) { - xfer += (*(this->success))[_i899].read(iprot); + xfer += (*(this->success))[_i907].read(iprot); } xfer += iprot->readListEnd(); } @@ -7016,14 +7016,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 _size900; - ::apache::thrift::protocol::TType _etype903; - xfer += iprot->readListBegin(_etype903, _size900); - this->success.resize(_size900); - uint32_t _i904; - for (_i904 = 0; _i904 < _size900; ++_i904) + 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) { - xfer += iprot->readString(this->success[_i904]); + xfer += iprot->readString(this->success[_i912]); } xfer += iprot->readListEnd(); } @@ -7078,10 +7078,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter905; - for (_iter905 = this->success.begin(); _iter905 != this->success.end(); ++_iter905) + std::vector<std::string> ::const_iterator _iter913; + for (_iter913 = this->success.begin(); _iter913 != this->success.end(); ++_iter913) { - xfer += oprot->writeString((*_iter905)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -7134,14 +7134,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 _size906; - ::apache::thrift::protocol::TType _etype909; - xfer += iprot->readListBegin(_etype909, _size906); - (*(this->success)).resize(_size906); - uint32_t _i910; - for (_i910 = 0; _i910 < _size906; ++_i910) + uint32_t _size914; + ::apache::thrift::protocol::TType _etype917; + xfer += iprot->readListBegin(_etype917, _size914); + (*(this->success)).resize(_size914); + uint32_t _i918; + for (_i918 = 0; _i918 < _size914; ++_i918) { - xfer += iprot->readString((*(this->success))[_i910]); + xfer += iprot->readString((*(this->success))[_i918]); } xfer += iprot->readListEnd(); } @@ -8475,14 +8475,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size911; - ::apache::thrift::protocol::TType _etype914; - xfer += iprot->readListBegin(_etype914, _size911); - this->new_parts.resize(_size911); - uint32_t _i915; - for (_i915 = 0; _i915 < _size911; ++_i915) + uint32_t _size919; + ::apache::thrift::protocol::TType _etype922; + xfer += iprot->readListBegin(_etype922, _size919); + this->new_parts.resize(_size919); + uint32_t _i923; + for (_i923 = 0; _i923 < _size919; ++_i923) { - xfer += this->new_parts[_i915].read(iprot); + xfer += this->new_parts[_i923].read(iprot); } xfer += iprot->readListEnd(); } @@ -8511,10 +8511,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<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter916; - for (_iter916 = this->new_parts.begin(); _iter916 != this->new_parts.end(); ++_iter916) + std::vector<Partition> ::const_iterator _iter924; + for (_iter924 = this->new_parts.begin(); _iter924 != this->new_parts.end(); ++_iter924) { - xfer += (*_iter916).write(oprot); + xfer += (*_iter924).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8538,10 +8538,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<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter917; - for (_iter917 = (*(this->new_parts)).begin(); _iter917 != (*(this->new_parts)).end(); ++_iter917) + std::vector<Partition> ::const_iterator _iter925; + for (_iter925 = (*(this->new_parts)).begin(); _iter925 != (*(this->new_parts)).end(); ++_iter925) { - xfer += (*_iter917).write(oprot); + xfer += (*_iter925).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8750,14 +8750,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 _size918; - ::apache::thrift::protocol::TType _etype921; - xfer += iprot->readListBegin(_etype921, _size918); - this->new_parts.resize(_size918); - uint32_t _i922; - for (_i922 = 0; _i922 < _size918; ++_i922) + uint32_t _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + this->new_parts.resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += this->new_parts[_i922].read(iprot); + xfer += this->new_parts[_i930].read(iprot); } xfer += iprot->readListEnd(); } @@ -8786,10 +8786,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<uint32_t>(this->new_parts.size())); - std::vector<PartitionSpec> ::const_iterator _iter923; - for (_iter923 = this->new_parts.begin(); _iter923 != this->new_parts.end(); ++_iter923) + std::vector<PartitionSpec> ::const_iterator _iter931; + for (_iter931 = this->new_parts.begin(); _iter931 != this->new_parts.end(); ++_iter931) { - xfer += (*_iter923).write(oprot); + xfer += (*_iter931).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8813,10 +8813,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<uint32_t>((*(this->new_parts)).size())); - std::vector<PartitionSpec> ::const_iterator _iter924; - for (_iter924 = (*(this->new_parts)).begin(); _iter924 != (*(this->new_parts)).end(); ++_iter924) + std::vector<PartitionSpec> ::const_iterator _iter932; + for (_iter932 = (*(this->new_parts)).begin(); _iter932 != (*(this->new_parts)).end(); ++_iter932) { - xfer += (*_iter924).write(oprot); + xfer += (*_iter932).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9041,14 +9041,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size925; - ::apache::thrift::protocol::TType _etype928; - xfer += iprot->readListBegin(_etype928, _size925); - this->part_vals.resize(_size925); - uint32_t _i929; - for (_i929 = 0; _i929 < _size925; ++_i929) + uint32_t _size933; + ::apache::thrift::protocol::TType _etype936; + xfer += iprot->readListBegin(_etype936, _size933); + this->part_vals.resize(_size933); + uint32_t _i937; + for (_i937 = 0; _i937 < _size933; ++_i937) { - xfer += iprot->readString(this->part_vals[_i929]); + xfer += iprot->readString(this->part_vals[_i937]); } xfer += iprot->readListEnd(); } @@ -9085,10 +9085,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter930; - for (_iter930 = this->part_vals.begin(); _iter930 != this->part_vals.end(); ++_iter930) + std::vector<std::string> ::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(); } @@ -9120,10 +9120,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter931; - for (_iter931 = (*(this->part_vals)).begin(); _iter931 != (*(this->part_vals)).end(); ++_iter931) + std::vector<std::string> ::const_iterator _iter939; + for (_iter939 = (*(this->part_vals)).begin(); _iter939 != (*(this->part_vals)).end(); ++_iter939) { - xfer += oprot->writeString((*_iter931)); + xfer += oprot->writeString((*_iter939)); } xfer += oprot->writeListEnd(); } @@ -9595,14 +9595,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - 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) + uint32_t _size940; + ::apache::thrift::protocol::TType _etype943; + xfer += iprot->readListBegin(_etype943, _size940); + this->part_vals.resize(_size940); + uint32_t _i944; + for (_i944 = 0; _i944 < _size940; ++_i944) { - xfer += iprot->readString(this->part_vals[_i936]); + xfer += iprot->readString(this->part_vals[_i944]); } xfer += iprot->readListEnd(); } @@ -9647,10 +9647,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter937; - for (_iter937 = this->part_vals.begin(); _iter937 != this->part_vals.end(); ++_iter937) + std::vector<std::string> ::const_iterator _iter945; + for (_iter945 = this->part_vals.begin(); _iter945 != this->part_vals.end(); ++_iter945) { - xfer += oprot->writeString((*_iter937)); + xfer += oprot->writeString((*_iter945)); } xfer += oprot->writeListEnd(); } @@ -9686,10 +9686,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter938; - for (_iter938 = (*(this->part_vals)).begin(); _iter938 != (*(this->part_vals)).end(); ++_iter938) + std::vector<std::string> ::const_iterator _iter946; + for (_iter946 = (*(this->part_vals)).begin(); _iter946 != (*(this->part_vals)).end(); ++_iter946) { - xfer += oprot->writeString((*_iter938)); + xfer += oprot->writeString((*_iter946)); } xfer += oprot->writeListEnd(); } @@ -10492,14 +10492,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size939; - ::apache::thrift::protocol::TType _etype942; - xfer += iprot->readListBegin(_etype942, _size939); - this->part_vals.resize(_size939); - uint32_t _i943; - for (_i943 = 0; _i943 < _size939; ++_i943) + uint32_t _size947; + ::apache::thrift::protocol::TType _etype950; + xfer += iprot->readListBegin(_etype950, _size947); + this->part_vals.resize(_size947); + uint32_t _i951; + for (_i951 = 0; _i951 < _size947; ++_i951) { - xfer += iprot->readString(this->part_vals[_i943]); + xfer += iprot->readString(this->part_vals[_i951]); } xfer += iprot->readListEnd(); } @@ -10544,10 +10544,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter944; - for (_iter944 = this->part_vals.begin(); _iter944 != this->part_vals.end(); ++_iter944) + std::vector<std::string> ::const_iterator _iter952; + for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952) { - xfer += oprot->writeString((*_iter944)); + xfer += oprot->writeString((*_iter952)); } xfer += oprot->writeListEnd(); } @@ -10583,10 +10583,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter945; - for (_iter945 = (*(this->part_vals)).begin(); _iter945 != (*(this->part_vals)).end(); ++_iter945) + std::vector<std::string> ::const_iterator _iter953; + for (_iter953 = (*(this->part_vals)).begin(); _iter953 != (*(this->part_vals)).end(); ++_iter953) { - xfer += oprot->writeString((*_iter945)); + xfer += oprot->writeString((*_iter953)); } xfer += oprot->writeListEnd(); } @@ -10795,14 +10795,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size946; - ::apache::thrift::protocol::TType _etype949; - xfer += iprot->readListBegin(_etype949, _size946); - this->part_vals.resize(_size946); - uint32_t _i950; - for (_i950 = 0; _i950 < _size946; ++_i950) + uint32_t _size954; + ::apache::thrift::protocol::TType _etype957; + xfer += iprot->readListBegin(_etype957, _size954); + this->part_vals.resize(_size954); + uint32_t _i958; + for (_i958 = 0; _i958 < _size954; ++_i958) { - xfer += iprot->readString(this->part_vals[_i950]); + xfer += iprot->readString(this->part_vals[_i958]); } xfer += iprot->readListEnd(); } @@ -10855,10 +10855,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter951; - for (_iter951 = this->part_vals.begin(); _iter951 != this->part_vals.end(); ++_iter951) + std::vector<std::string> ::const_iterator _iter959; + for (_iter959 = this->part_vals.begin(); _iter959 != this->part_vals.end(); ++_iter959) { - xfer += oprot->writeString((*_iter951)); + xfer += oprot->writeString((*_iter959)); } xfer += oprot->writeListEnd(); } @@ -10898,10 +10898,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter952; - for (_iter952 = (*(this->part_vals)).begin(); _iter952 != (*(this->part_vals)).end(); ++_iter952) + std::vector<std::string> ::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(); } @@ -11907,14 +11907,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size953; - ::apache::thrift::protocol::TType _etype956; - xfer += iprot->readListBegin(_etype956, _size953); - this->part_vals.resize(_size953); - uint32_t _i957; - for (_i957 = 0; _i957 < _size953; ++_i957) + uint32_t _size961; + ::apache::thrift::protocol::TType _etype964; + xfer += iprot->readListBegin(_etype964, _size961); + this->part_vals.resize(_size961); + uint32_t _i965; + for (_i965 = 0; _i965 < _size961; ++_i965) { - xfer += iprot->readString(this->part_vals[_i957]); + xfer += iprot->readString(this->part_vals[_i965]); } xfer += iprot->readListEnd(); } @@ -11951,10 +11951,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter958; - for (_iter958 = this->part_vals.begin(); _iter958 != this->part_vals.end(); ++_iter958) + std::vector<std::string> ::const_iterator _iter966; + for (_iter966 = this->part_vals.begin(); _iter966 != this->part_vals.end(); ++_iter966) { - xfer += oprot->writeString((*_iter958)); + xfer += oprot->writeString((*_iter966)); } xfer += oprot->writeListEnd(); } @@ -11986,10 +11986,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter959; - for (_iter959 = (*(this->part_vals)).begin(); _iter959 != (*(this->part_vals)).end(); ++_iter959) + std::vector<std::string> ::const_iterator _iter967; + for (_iter967 = (*(this->part_vals)).begin(); _iter967 != (*(this->part_vals)).end(); ++_iter967) { - xfer += oprot->writeString((*_iter959)); + xfer += oprot->writeString((*_iter967)); } xfer += oprot->writeListEnd(); } @@ -12178,17 +12178,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size960; - ::apache::thrift::protocol::TType _ktype961; - ::apache::thrift::protocol::TType _vtype962; - xfer += iprot->readMapBegin(_ktype961, _vtype962, _size960); - uint32_t _i964; - for (_i964 = 0; _i964 < _size960; ++_i964) + uint32_t _size968; + ::apache::thrift::protocol::TType _ktype969; + ::apache::thrift::protocol::TType _vtype970; + xfer += iprot->readMapBegin(_ktype969, _vtype970, _size968); + uint32_t _i972; + for (_i972 = 0; _i972 < _size968; ++_i972) { - std::string _key965; - xfer += iprot->readString(_key965); - std::string& _val966 = this->partitionSpecs[_key965]; - xfer += iprot->readString(_val966); + std::string _key973; + xfer += iprot->readString(_key973); + std::string& _val974 = this->partitionSpecs[_key973]; + xfer += iprot->readString(_val974); } xfer += iprot->readMapEnd(); } @@ -12249,11 +12249,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<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter967; - for (_iter967 = this->partitionSpecs.begin(); _iter967 != this->partitionSpecs.end(); ++_iter967) + std::map<std::string, std::string> ::const_iterator _iter975; + for (_iter975 = this->partitionSpecs.begin(); _iter975 != this->partitionSpecs.end(); ++_iter975) { - xfer += oprot->writeString(_iter967->first); - xfer += oprot->writeString(_iter967->second); + xfer += oprot->writeString(_iter975->first); + xfer += oprot->writeString(_iter975->second); } xfer += oprot->writeMapEnd(); } @@ -12293,11 +12293,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<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter968; - for (_iter968 = (*(this->partitionSpecs)).begin(); _iter968 != (*(this->partitionSpecs)).end(); ++_iter968) + std::map<std::string, std::string> ::const_iterator _iter976; + for (_iter976 = (*(this->partitionSpecs)).begin(); _iter976 != (*(this->partitionSpecs)).end(); ++_iter976) { - xfer += oprot->writeString(_iter968->first); - xfer += oprot->writeString(_iter968->second); + xfer += oprot->writeString(_iter976->first); + xfer += oprot->writeString(_iter976->second); } xfer += oprot->writeMapEnd(); } @@ -12542,17 +12542,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size969; - ::apache::thrift::protocol::TType _ktype970; - ::apache::thrift::protocol::TType _vtype971; - xfer += iprot->readMapBegin(_ktype970, _vtype971, _size969); - uint32_t _i973; - for (_i973 = 0; _i973 < _size969; ++_i973) + uint32_t _size977; + ::apache::thrift::protocol::TType _ktype978; + ::apache::thrift::protocol::TType _vtype979; + xfer += iprot->readMapBegin(_ktype978, _vtype979, _size977); + uint32_t _i981; + for (_i981 = 0; _i981 < _size977; ++_i981) { - std::string _key974; - xfer += iprot->readString(_key974); - std::string& _val975 = this->partitionSpecs[_key974]; - xfer += iprot->readString(_val975); + std::string _key982; + xfer += iprot->readString(_key982); + std::string& _val983 = this->partitionSpecs[_key982]; + xfer += iprot->readString(_val983); } xfer += iprot->readMapEnd(); } @@ -12613,11 +12613,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<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter976; - for (_iter976 = this->partitionSpecs.begin(); _iter976 != this->partitionSpecs.end(); ++_iter976) + std::map<std::string, std::string> ::const_iterator _iter984; + for (_iter984 = this->partitionSpecs.begin(); _iter984 != this->partitionSpecs.end(); ++_iter984) { - xfer += oprot->writeString(_iter976->first); - xfer += oprot->writeString(_iter976->second); + xfer += oprot->writeString(_iter984->first); + xfer += oprot->writeString(_iter984->second); } xfer += oprot->writeMapEnd(); } @@ -12657,11 +12657,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<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter977; - for (_iter977 = (*(this->partitionSpecs)).begin(); _iter977 != (*(this->partitionSpecs)).end(); ++_iter977) + std::map<std::string, std::string> ::const_iterator _iter985; + for (_iter985 = (*(this->partitionSpecs)).begin(); _iter985 != (*(this->partitionSpecs)).end(); ++_iter985) { - xfer += oprot->writeString(_iter977->first); - xfer += oprot->writeString(_iter977->second); + xfer += oprot->writeString(_iter985->first); + xfer += oprot->writeString(_iter985->second); } xfer += oprot->writeMapEnd(); } @@ -12718,14 +12718,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size978; - ::apache::thrift::protocol::TType _etype981; - xfer += iprot->readListBegin(_etype981, _size978); - this->success.resize(_size978); - uint32_t _i982; - for (_i982 = 0; _i982 < _size978; ++_i982) + uint32_t _size986; + ::apache::thrift::protocol::TType _etype989; + xfer += iprot->readListBegin(_etype989, _size986); + this->success.resize(_size986); + uint32_t _i990; + for (_i990 = 0; _i990 < _size986; ++_i990) { - xfer += this->success[_i982].read(iprot); + xfer += this->success[_i990].read(iprot); } xfer += iprot->readListEnd(); } @@ -12788,10 +12788,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<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter983; - for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983) + std::vector<Partition> ::const_iterator _iter991; + for (_iter991 = this->success.begin(); _iter991 != this->success.end(); ++_iter991) { - xfer += (*_iter983).write(oprot); + xfer += (*_iter991).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12848,14 +12848,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size984; - ::apache::thrift::protocol::TType _etype987; - xfer += iprot->readListBegin(_etype987, _size984); - (*(this->success)).resize(_size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size992; + ::apache::thrift::protocol::TType _etype995; + xfer += iprot->readListBegin(_etype995, _size992); + (*(this->success)).resize(_size992); + uint32_t _i996; + for (_i996 = 0; _i996 < _size992; ++_i996) { - xfer += (*(this->success))[_i988].read(iprot); + xfer += (*(this->success))[_i996].read(iprot); } xfer += iprot->readListEnd(); } @@ -12954,14 +12954,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 _size989; - ::apache::thrift::protocol::TType _etype992; - xfer += iprot->readListBegin(_etype992, _size989); - this->part_vals.resize(_size989); - uint32_t _i993; - for (_i993 = 0; _i993 < _size989; ++_i993) + uint32_t _size997; + ::apache::thrift::protocol::TType _etype1000; + xfer += iprot->readListBegin(_etype1000, _size997); + this->part_vals.resize(_size997); + uint32_t _i1001; + for (_i1001 = 0; _i1001 < _size997; ++_i1001) { - xfer += iprot->readString(this->part_vals[_i993]); + xfer += iprot->readString(this->part_vals[_i1001]); } xfer += iprot->readListEnd(); } @@ -12982,14 +12982,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 _size994; - ::apache::thrift::protocol::TType _etype997; - xfer += iprot->readListBegin(_etype997, _size994); - this->group_names.resize(_size994); - uint32_t _i998; - for (_i998 = 0; _i998 < _size994; ++_i998) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + this->group_names.resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += iprot->readString(this->group_names[_i998]); + xfer += iprot->readString(this->group_names[_i1006]); } xfer += iprot->readListEnd(); } @@ -13026,10 +13026,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter999; - for (_iter999 = this->part_vals.begin(); _iter999 != this->part_vals.end(); ++_iter999) + std::vector<std::string> ::const_iterator _iter1007; + for (_iter1007 = this->part_vals.begin(); _iter1007 != this->part_vals.end(); ++_iter1007) { - xfer += oprot->writeString((*_iter999)); + xfer += oprot->writeString((*_iter1007)); } xfer += oprot->writeListEnd(); } @@ -13042,10 +13042,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<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1000; - for (_iter1000 = this->group_names.begin(); _iter1000 != this->group_names.end(); ++_iter1000) + std::vector<std::string> ::const_iterator _iter1008; + for (_iter1008 = this->group_names.begin(); _iter1008 != this->group_names.end(); ++_iter1008) { - xfer += oprot->writeString((*_iter1000)); + xfer += oprot->writeString((*_iter1008)); } xfer += oprot->writeListEnd(); } @@ -13077,10 +13077,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1001; - for (_iter1001 = (*(this->part_vals)).begin(); _iter1001 != (*(this->part_vals)).end(); ++_iter1001) + std::vector<std::string> ::const_iterator _iter1009; + for (_iter1009 = (*(this->part_vals)).begin(); _iter1009 != (*(this->part_vals)).end(); ++_iter1009) { - xfer += oprot->writeString((*_iter1001)); + xfer += oprot->writeString((*_iter1009)); } xfer += oprot->writeListEnd(); } @@ -13093,10 +13093,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<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1002; - for (_iter1002 = (*(this->group_names)).begin(); _iter1002 != (*(this->group_names)).end(); ++_iter1002) + std::vector<std::string> ::const_iterator _iter1010; + for (_iter1010 = (*(this->group_names)).begin(); _iter1010 != (*(this->group_names)).end(); ++_iter1010) { - xfer += oprot->writeString((*_iter1002)); + xfer += oprot->writeString((*_iter1010)); } xfer += oprot->writeListEnd(); } @@ -13655,14 +13655,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1003; - ::apache::thrift::protocol::TType _etype1006; - xfer += iprot->readListBegin(_etype1006, _size1003); - this->success.resize(_size1003); - uint32_t _i1007; - for (_i1007 = 0; _i1007 < _size1003; ++_i1007) + uint32_t _size1011; + ::apache::thrift::protocol::TType _etype1014; + xfer += iprot->readListBegin(_etype1014, _size1011); + this->success.resize(_size1011); + uint32_t _i1015; + for (_i1015 = 0; _i1015 < _size1011; ++_i1015) { - xfer += this->success[_i1007].read(iprot); + xfer += this->success[_i1015].read(iprot); } xfer += iprot->readListEnd(); } @@ -13709,10 +13709,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<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1008; - for (_iter1008 = this->success.begin(); _iter1008 != this->success.end(); ++_iter1008) + std::vector<Partition> ::const_iterator _iter1016; + for (_iter1016 = this->success.begin(); _iter1016 != this->success.end(); ++_iter1016) { - xfer += (*_iter1008).write(oprot); + xfer += (*_iter1016).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13761,14 +13761,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1009; - ::apache::thrift::protocol::TType _etype1012; - xfer += iprot->readListBegin(_etype1012, _size1009); - (*(this->success)).resize(_size1009); - uint32_t _i1013; - for (_i1013 = 0; _i1013 < _size1009; ++_i1013) + uint32_t _size1017; + ::apache::thrift::protocol::TType _etype1020; + xfer += iprot->readListBegin(_etype1020, _size1017); + (*(this->success)).resize(_size1017); + uint32_t _i1021; + for (_i1021 = 0; _i1021 < _size1017; ++_i1021) { - xfer += (*(this->success))[_i1013].read(iprot); + xfer += (*(this->success))[_i1021].read(iprot); } xfer += iprot->readListEnd(); } @@ -13867,14 +13867,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 _size1014; - ::apache::thrift::protocol::TType _etype1017; - xfer += iprot->readListBegin(_etype1017, _size1014); - this->group_names.resize(_size1014); - uint32_t _i1018; - for (_i1018 = 0; _i1018 < _size1014; ++_i1018) + uint32_t _size1022; + ::apache::thrift::protocol::TType _etype1025; + xfer += iprot->readListBegin(_etype1025, _size1022); + this->group_names.resize(_size1022); + uint32_t _i1026; + for (_i1026 = 0; _i1026 < _size1022; ++_i1026) { - xfer += iprot->readString(this->group_names[_i1018]); + xfer += iprot->readString(this->group_names[_i1026]); } xfer += iprot->readListEnd(); } @@ -13919,10 +13919,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<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1019; - for (_iter1019 = this->group_names.begin(); _iter1019 != this->group_names.end(); ++_iter1019) + std::vector<std::string> ::const_iterator _iter1027; + for (_iter1027 = this->group_names.begin(); _iter1027 != this->group_names.end(); ++_iter1027) { - xfer += oprot->writeString((*_iter1019)); + xfer += oprot->writeString((*_iter1027)); } xfer += oprot->writeListEnd(); } @@ -13962,10 +13962,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<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1020; - for (_iter1020 = (*(this->group_names)).begin(); _iter1020 != (*(this->group_names)).end(); ++_iter1020) + std::vector<std::string> ::const_iterator _iter1028; + for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028) { - xfer += oprot->writeString((*_iter1020)); + xfer += oprot->writeString((*_iter1028)); } xfer += oprot->writeListEnd(); } @@ -14006,14 +14006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1021; - ::apache::thrift::protocol::TType _etype1024; - xfer += iprot->readListBegin(_etype1024, _size1021); - this->success.resize(_size1021); - uint32_t _i1025; - for (_i1025 = 0; _i1025 < _size1021; ++_i1025) + uint32_t _size1029; + ::apache::thrift::protocol::TType _etype1032; + xfer += iprot->readListBegin(_etype1032, _size1029); + this->success.resize(_size1029); + uint32_t _i1033; + for (_i1033 = 0; _i1033 < _size1029; ++_i1033) { - xfer += this->success[_i1025].read(iprot); + xfer += this->success[_i1033].read(iprot); } xfer += iprot->readListEnd(); } @@ -14060,10 +14060,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<uint32_t>(this->success.size())); - std::vector<Partition> ::const_iterator _iter1026; - for (_iter1026 = this->success.begin(); _iter1026 != this->success.end(); ++_iter1026) + std::vector<Partition> ::const_iterator _iter1034; + for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034) { - xfer += (*_iter1026).write(oprot); + xfer += (*_iter1034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14112,14 +14112,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1027; - ::apache::thrift::protocol::TType _etype1030; - xfer += iprot->readListBegin(_etype1030, _size1027); - (*(this->success)).resize(_size1027); - uint32_t _i1031; - for (_i1031 = 0; _i1031 < _size1027; ++_i1031) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + (*(this->success)).resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += (*(this->success))[_i1031].read(iprot); + xfer += (*(this->success))[_i1039].read(iprot); } xfer += iprot->readListEnd(); } @@ -14297,14 +14297,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1032; - ::apache::thrift::protocol::TType _etype1035; - xfer += iprot->readListBegin(_etype1035, _size1032); - this->success.resize(_size1032); - uint32_t _i1036; - for (_i1036 = 0; _i1036 < _size1032; ++_i1036) + uint32_t _size1040; + ::apache::thrift::protocol::TType _etype1043; + xfer += iprot->readListBegin(_etype1043, _size1040); + this->success.resize(_size1040); + uint32_t _i1044; + for (_i1044 = 0; _i1044 < _size1040; ++_i1044) { - xfer += this->success[_i1036].read(iprot); + xfer += this->success[_i1044].read(iprot); } xfer += iprot->readListEnd(); } @@ -14351,10 +14351,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<uint32_t>(this->success.size())); - std::vector<PartitionSpec> ::const_iterator _iter1037; - for (_iter1037 = this->success.begin(); _iter1037 != this->success.end(); ++_iter1037) + std::vector<PartitionSpec> ::const_iterator _iter1045; + for (_iter1045 = this->success.begin(); _iter1045 != this->success.end(); ++_iter1045) { - xfer += (*_iter1037).write(oprot); + xfer += (*_iter1045).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14403,14 +14403,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1038; - ::apache::thrift::protocol::TType _etype1041; - xfer += iprot->readListBegin(_etype1041, _size1038); - (*(this->success)).resize(_size1038); - uint32_t _i1042; - for (_i1042 = 0; _i1042 < _size1038; ++_i1042) + uint32_t _size1046; + ::apache::thrift::protocol::TType _etype1049; + xfer += iprot->readListBegin(_etype1049, _size1046); + (*(this->success)).resize(_size1046); + uint32_t _i1050; + for (_i1050 = 0; _i1050 < _size1046; ++_i1050) { - xfer += (*(this->success))[_i1042].read(iprot); + xfer += (*(this->success))[_i1050].read(iprot); } xfer += iprot->readListEnd(); } @@ -14588,14 +14588,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1043; - ::apache::thrift::protocol::TType _etype1046; - xfer += iprot->readListBegin(_etype1046, _size1043); - this->success.resize(_size1043); - uint32_t _i1047; - for (_i1047 = 0; _i1047 < _size1043; ++_i1047) + uint32_t _size1051; + ::apache::thrift::protocol::TType _etype1054; + xfer += iprot->readListBegin(_etype1054, _size1051); + this->success.resize(_size1051); + uint32_t _i1055; + for (_i1055 = 0; _i1055 < _size1051; ++_i1055) { - xfer += iprot->readString(this->success[_i1047]); + xfer += iprot->readString(this->success[_i1055]); } xfer += iprot->readListEnd(); } @@ -14634,10 +14634,10 @@ uint32_t ThriftHiveMetastore_get_part
<TRUNCATED>