http://git-wip-us.apache.org/repos/asf/hive/blob/117c3b47/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 155aab6..35aafe7 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 _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 _size849; + ::apache::thrift::protocol::TType _etype852; + xfer += iprot->readListBegin(_etype852, _size849); + this->success.resize(_size849); + uint32_t _i853; + for (_i853 = 0; _i853 < _size849; ++_i853) { - xfer += iprot->readString(this->success[_i852]); + xfer += iprot->readString(this->success[_i853]); } 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 _iter853; - for (_iter853 = this->success.begin(); _iter853 != this->success.end(); ++_iter853) + std::vector<std::string> ::const_iterator _iter854; + for (_iter854 = this->success.begin(); _iter854 != this->success.end(); ++_iter854) { - xfer += oprot->writeString((*_iter853)); + xfer += oprot->writeString((*_iter854)); } 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 _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 _size855; + ::apache::thrift::protocol::TType _etype858; + xfer += iprot->readListBegin(_etype858, _size855); + (*(this->success)).resize(_size855); + uint32_t _i859; + for (_i859 = 0; _i859 < _size855; ++_i859) { - xfer += iprot->readString((*(this->success))[_i858]); + xfer += iprot->readString((*(this->success))[_i859]); } 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 _size859; - ::apache::thrift::protocol::TType _etype862; - xfer += iprot->readListBegin(_etype862, _size859); - this->success.resize(_size859); - uint32_t _i863; - for (_i863 = 0; _i863 < _size859; ++_i863) + 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) { - xfer += iprot->readString(this->success[_i863]); + xfer += iprot->readString(this->success[_i864]); } 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 _iter864; - for (_iter864 = this->success.begin(); _iter864 != this->success.end(); ++_iter864) + std::vector<std::string> ::const_iterator _iter865; + for (_iter865 = this->success.begin(); _iter865 != this->success.end(); ++_iter865) { - xfer += oprot->writeString((*_iter864)); + xfer += oprot->writeString((*_iter865)); } 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 _size865; - ::apache::thrift::protocol::TType _etype868; - xfer += iprot->readListBegin(_etype868, _size865); - (*(this->success)).resize(_size865); - uint32_t _i869; - for (_i869 = 0; _i869 < _size865; ++_i869) + 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) { - xfer += iprot->readString((*(this->success))[_i869]); + xfer += iprot->readString((*(this->success))[_i870]); } 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 _size870; - ::apache::thrift::protocol::TType _ktype871; - ::apache::thrift::protocol::TType _vtype872; - xfer += iprot->readMapBegin(_ktype871, _vtype872, _size870); - uint32_t _i874; - for (_i874 = 0; _i874 < _size870; ++_i874) + uint32_t _size871; + ::apache::thrift::protocol::TType _ktype872; + ::apache::thrift::protocol::TType _vtype873; + xfer += iprot->readMapBegin(_ktype872, _vtype873, _size871); + uint32_t _i875; + for (_i875 = 0; _i875 < _size871; ++_i875) { - std::string _key875; - xfer += iprot->readString(_key875); - Type& _val876 = this->success[_key875]; - xfer += _val876.read(iprot); + std::string _key876; + xfer += iprot->readString(_key876); + Type& _val877 = this->success[_key876]; + xfer += _val877.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 _iter877; - for (_iter877 = this->success.begin(); _iter877 != this->success.end(); ++_iter877) + std::map<std::string, Type> ::const_iterator _iter878; + for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) { - xfer += oprot->writeString(_iter877->first); - xfer += _iter877->second.write(oprot); + xfer += oprot->writeString(_iter878->first); + xfer += _iter878->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 _size878; - ::apache::thrift::protocol::TType _ktype879; - ::apache::thrift::protocol::TType _vtype880; - xfer += iprot->readMapBegin(_ktype879, _vtype880, _size878); - uint32_t _i882; - for (_i882 = 0; _i882 < _size878; ++_i882) + uint32_t _size879; + ::apache::thrift::protocol::TType _ktype880; + ::apache::thrift::protocol::TType _vtype881; + xfer += iprot->readMapBegin(_ktype880, _vtype881, _size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - std::string _key883; - xfer += iprot->readString(_key883); - Type& _val884 = (*(this->success))[_key883]; - xfer += _val884.read(iprot); + std::string _key884; + xfer += iprot->readString(_key884); + Type& _val885 = (*(this->success))[_key884]; + xfer += _val885.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 _size885; - ::apache::thrift::protocol::TType _etype888; - xfer += iprot->readListBegin(_etype888, _size885); - this->success.resize(_size885); - uint32_t _i889; - for (_i889 = 0; _i889 < _size885; ++_i889) + uint32_t _size886; + ::apache::thrift::protocol::TType _etype889; + xfer += iprot->readListBegin(_etype889, _size886); + this->success.resize(_size886); + uint32_t _i890; + for (_i890 = 0; _i890 < _size886; ++_i890) { - xfer += this->success[_i889].read(iprot); + xfer += this->success[_i890].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 _iter890; - for (_iter890 = this->success.begin(); _iter890 != this->success.end(); ++_iter890) + std::vector<FieldSchema> ::const_iterator _iter891; + for (_iter891 = this->success.begin(); _iter891 != this->success.end(); ++_iter891) { - xfer += (*_iter890).write(oprot); + xfer += (*_iter891).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 _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 _size892; + ::apache::thrift::protocol::TType _etype895; + xfer += iprot->readListBegin(_etype895, _size892); + (*(this->success)).resize(_size892); + uint32_t _i896; + for (_i896 = 0; _i896 < _size892; ++_i896) { - xfer += (*(this->success))[_i895].read(iprot); + xfer += (*(this->success))[_i896].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 _size896; - ::apache::thrift::protocol::TType _etype899; - xfer += iprot->readListBegin(_etype899, _size896); - this->success.resize(_size896); - uint32_t _i900; - for (_i900 = 0; _i900 < _size896; ++_i900) + 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[_i900].read(iprot); + xfer += this->success[_i901].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 _iter901; - for (_iter901 = this->success.begin(); _iter901 != this->success.end(); ++_iter901) + std::vector<FieldSchema> ::const_iterator _iter902; + for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) { - xfer += (*_iter901).write(oprot); + xfer += (*_iter902).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 _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 _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))[_i906].read(iprot); + xfer += (*(this->success))[_i907].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 _size907; - ::apache::thrift::protocol::TType _etype910; - xfer += iprot->readListBegin(_etype910, _size907); - this->success.resize(_size907); - uint32_t _i911; - for (_i911 = 0; _i911 < _size907; ++_i911) + 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 += this->success[_i911].read(iprot); + xfer += this->success[_i912].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 _iter912; - for (_iter912 = this->success.begin(); _iter912 != this->success.end(); ++_iter912) + std::vector<FieldSchema> ::const_iterator _iter913; + for (_iter913 = this->success.begin(); _iter913 != this->success.end(); ++_iter913) { - xfer += (*_iter912).write(oprot); + xfer += (*_iter913).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 _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 _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 += (*(this->success))[_i917].read(iprot); + xfer += (*(this->success))[_i918].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 _size918; - ::apache::thrift::protocol::TType _etype921; - xfer += iprot->readListBegin(_etype921, _size918); - this->success.resize(_size918); - uint32_t _i922; - for (_i922 = 0; _i922 < _size918; ++_i922) + 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) { - xfer += this->success[_i922].read(iprot); + xfer += this->success[_i923].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 _iter923; - for (_iter923 = this->success.begin(); _iter923 != this->success.end(); ++_iter923) + std::vector<FieldSchema> ::const_iterator _iter924; + for (_iter924 = this->success.begin(); _iter924 != this->success.end(); ++_iter924) { - xfer += (*_iter923).write(oprot); + xfer += (*_iter924).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 _size924; - ::apache::thrift::protocol::TType _etype927; - xfer += iprot->readListBegin(_etype927, _size924); - (*(this->success)).resize(_size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + uint32_t _size925; + ::apache::thrift::protocol::TType _etype928; + xfer += iprot->readListBegin(_etype928, _size925); + (*(this->success)).resize(_size925); + uint32_t _i929; + for (_i929 = 0; _i929 < _size925; ++_i929) { - xfer += (*(this->success))[_i928].read(iprot); + xfer += (*(this->success))[_i929].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 _size929; - ::apache::thrift::protocol::TType _etype932; - xfer += iprot->readListBegin(_etype932, _size929); - this->primaryKeys.resize(_size929); - uint32_t _i933; - for (_i933 = 0; _i933 < _size929; ++_i933) + uint32_t _size930; + ::apache::thrift::protocol::TType _etype933; + xfer += iprot->readListBegin(_etype933, _size930); + this->primaryKeys.resize(_size930); + uint32_t _i934; + for (_i934 = 0; _i934 < _size930; ++_i934) { - xfer += this->primaryKeys[_i933].read(iprot); + xfer += this->primaryKeys[_i934].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 _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->foreignKeys.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size935; + ::apache::thrift::protocol::TType _etype938; + xfer += iprot->readListBegin(_etype938, _size935); + this->foreignKeys.resize(_size935); + uint32_t _i939; + for (_i939 = 0; _i939 < _size935; ++_i939) { - xfer += this->foreignKeys[_i938].read(iprot); + xfer += this->foreignKeys[_i939].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 _iter939; - for (_iter939 = this->primaryKeys.begin(); _iter939 != this->primaryKeys.end(); ++_iter939) + std::vector<SQLPrimaryKey> ::const_iterator _iter940; + for (_iter940 = this->primaryKeys.begin(); _iter940 != this->primaryKeys.end(); ++_iter940) { - xfer += (*_iter939).write(oprot); + xfer += (*_iter940).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 _iter940; - for (_iter940 = this->foreignKeys.begin(); _iter940 != this->foreignKeys.end(); ++_iter940) + std::vector<SQLForeignKey> ::const_iterator _iter941; + for (_iter941 = this->foreignKeys.begin(); _iter941 != this->foreignKeys.end(); ++_iter941) { - xfer += (*_iter940).write(oprot); + xfer += (*_iter941).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 _iter941; - for (_iter941 = (*(this->primaryKeys)).begin(); _iter941 != (*(this->primaryKeys)).end(); ++_iter941) + std::vector<SQLPrimaryKey> ::const_iterator _iter942; + for (_iter942 = (*(this->primaryKeys)).begin(); _iter942 != (*(this->primaryKeys)).end(); ++_iter942) { - xfer += (*_iter941).write(oprot); + xfer += (*_iter942).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 _iter942; - for (_iter942 = (*(this->foreignKeys)).begin(); _iter942 != (*(this->foreignKeys)).end(); ++_iter942) + std::vector<SQLForeignKey> ::const_iterator _iter943; + for (_iter943 = (*(this->foreignKeys)).begin(); _iter943 != (*(this->foreignKeys)).end(); ++_iter943) { - xfer += (*_iter942).write(oprot); + xfer += (*_iter943).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6055,14 +6055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size943; - ::apache::thrift::protocol::TType _etype946; - xfer += iprot->readListBegin(_etype946, _size943); - this->success.resize(_size943); - uint32_t _i947; - for (_i947 = 0; _i947 < _size943; ++_i947) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + this->success.resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += iprot->readString(this->success[_i947]); + xfer += iprot->readString(this->success[_i948]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6101,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 _iter948; - for (_iter948 = this->success.begin(); _iter948 != this->success.end(); ++_iter948) + std::vector<std::string> ::const_iterator _iter949; + for (_iter949 = this->success.begin(); _iter949 != this->success.end(); ++_iter949) { - xfer += oprot->writeString((*_iter948)); + xfer += oprot->writeString((*_iter949)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - (*(this->success)).resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + uint32_t _size950; + ::apache::thrift::protocol::TType _etype953; + xfer += iprot->readListBegin(_etype953, _size950); + (*(this->success)).resize(_size950); + uint32_t _i954; + for (_i954 = 0; _i954 < _size950; ++_i954) { - xfer += iprot->readString((*(this->success))[_i953]); + xfer += iprot->readString((*(this->success))[_i954]); } xfer += iprot->readListEnd(); } @@ -6326,14 +6326,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size954; - ::apache::thrift::protocol::TType _etype957; - xfer += iprot->readListBegin(_etype957, _size954); - this->success.resize(_size954); - uint32_t _i958; - for (_i958 = 0; _i958 < _size954; ++_i958) + uint32_t _size955; + ::apache::thrift::protocol::TType _etype958; + xfer += iprot->readListBegin(_etype958, _size955); + this->success.resize(_size955); + uint32_t _i959; + for (_i959 = 0; _i959 < _size955; ++_i959) { - xfer += iprot->readString(this->success[_i958]); + xfer += iprot->readString(this->success[_i959]); } xfer += iprot->readListEnd(); } @@ -6372,10 +6372,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: 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 _iter959; - for (_iter959 = this->success.begin(); _iter959 != this->success.end(); ++_iter959) + std::vector<std::string> ::const_iterator _iter960; + for (_iter960 = this->success.begin(); _iter960 != this->success.end(); ++_iter960) { - xfer += oprot->writeString((*_iter959)); + xfer += oprot->writeString((*_iter960)); } xfer += oprot->writeListEnd(); } @@ -6420,14 +6420,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size960; - ::apache::thrift::protocol::TType _etype963; - xfer += iprot->readListBegin(_etype963, _size960); - (*(this->success)).resize(_size960); - uint32_t _i964; - for (_i964 = 0; _i964 < _size960; ++_i964) + uint32_t _size961; + ::apache::thrift::protocol::TType _etype964; + xfer += iprot->readListBegin(_etype964, _size961); + (*(this->success)).resize(_size961); + uint32_t _i965; + for (_i965 = 0; _i965 < _size961; ++_i965) { - xfer += iprot->readString((*(this->success))[_i964]); + xfer += iprot->readString((*(this->success))[_i965]); } xfer += iprot->readListEnd(); } @@ -6502,14 +6502,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 _size965; - ::apache::thrift::protocol::TType _etype968; - xfer += iprot->readListBegin(_etype968, _size965); - this->tbl_types.resize(_size965); - uint32_t _i969; - for (_i969 = 0; _i969 < _size965; ++_i969) + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->tbl_types.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) { - xfer += iprot->readString(this->tbl_types[_i969]); + xfer += iprot->readString(this->tbl_types[_i970]); } xfer += iprot->readListEnd(); } @@ -6546,10 +6546,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 _iter970; - for (_iter970 = this->tbl_types.begin(); _iter970 != this->tbl_types.end(); ++_iter970) + std::vector<std::string> ::const_iterator _iter971; + for (_iter971 = this->tbl_types.begin(); _iter971 != this->tbl_types.end(); ++_iter971) { - xfer += oprot->writeString((*_iter970)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -6581,10 +6581,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 _iter971; - for (_iter971 = (*(this->tbl_types)).begin(); _iter971 != (*(this->tbl_types)).end(); ++_iter971) + std::vector<std::string> ::const_iterator _iter972; + for (_iter972 = (*(this->tbl_types)).begin(); _iter972 != (*(this->tbl_types)).end(); ++_iter972) { - xfer += oprot->writeString((*_iter971)); + xfer += oprot->writeString((*_iter972)); } xfer += oprot->writeListEnd(); } @@ -6625,14 +6625,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size972; - ::apache::thrift::protocol::TType _etype975; - xfer += iprot->readListBegin(_etype975, _size972); - this->success.resize(_size972); - uint32_t _i976; - for (_i976 = 0; _i976 < _size972; ++_i976) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + this->success.resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += this->success[_i976].read(iprot); + xfer += this->success[_i977].read(iprot); } xfer += iprot->readListEnd(); } @@ -6671,10 +6671,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 _iter977; - for (_iter977 = this->success.begin(); _iter977 != this->success.end(); ++_iter977) + std::vector<TableMeta> ::const_iterator _iter978; + for (_iter978 = this->success.begin(); _iter978 != this->success.end(); ++_iter978) { - xfer += (*_iter977).write(oprot); + xfer += (*_iter978).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6719,14 +6719,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot 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 _size979; + ::apache::thrift::protocol::TType _etype982; + xfer += iprot->readListBegin(_etype982, _size979); + (*(this->success)).resize(_size979); + uint32_t _i983; + for (_i983 = 0; _i983 < _size979; ++_i983) { - xfer += (*(this->success))[_i982].read(iprot); + xfer += (*(this->success))[_i983].read(iprot); } xfer += iprot->readListEnd(); } @@ -6864,14 +6864,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size983; - ::apache::thrift::protocol::TType _etype986; - xfer += iprot->readListBegin(_etype986, _size983); - this->success.resize(_size983); - uint32_t _i987; - for (_i987 = 0; _i987 < _size983; ++_i987) + 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) { - xfer += iprot->readString(this->success[_i987]); + xfer += iprot->readString(this->success[_i988]); } xfer += iprot->readListEnd(); } @@ -6910,10 +6910,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 _iter988; - for (_iter988 = this->success.begin(); _iter988 != this->success.end(); ++_iter988) + std::vector<std::string> ::const_iterator _iter989; + for (_iter989 = this->success.begin(); _iter989 != this->success.end(); ++_iter989) { - xfer += oprot->writeString((*_iter988)); + xfer += oprot->writeString((*_iter989)); } xfer += oprot->writeListEnd(); } @@ -6958,14 +6958,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size989; - ::apache::thrift::protocol::TType _etype992; - xfer += iprot->readListBegin(_etype992, _size989); - (*(this->success)).resize(_size989); - uint32_t _i993; - for (_i993 = 0; _i993 < _size989; ++_i993) + uint32_t _size990; + ::apache::thrift::protocol::TType _etype993; + xfer += iprot->readListBegin(_etype993, _size990); + (*(this->success)).resize(_size990); + uint32_t _i994; + for (_i994 = 0; _i994 < _size990; ++_i994) { - xfer += iprot->readString((*(this->success))[_i993]); + xfer += iprot->readString((*(this->success))[_i994]); } xfer += iprot->readListEnd(); } @@ -7275,14 +7275,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 _size994; - ::apache::thrift::protocol::TType _etype997; - xfer += iprot->readListBegin(_etype997, _size994); - this->tbl_names.resize(_size994); - uint32_t _i998; - for (_i998 = 0; _i998 < _size994; ++_i998) + uint32_t _size995; + ::apache::thrift::protocol::TType _etype998; + xfer += iprot->readListBegin(_etype998, _size995); + this->tbl_names.resize(_size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - xfer += iprot->readString(this->tbl_names[_i998]); + xfer += iprot->readString(this->tbl_names[_i999]); } xfer += iprot->readListEnd(); } @@ -7315,10 +7315,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 _iter999; - for (_iter999 = this->tbl_names.begin(); _iter999 != this->tbl_names.end(); ++_iter999) + std::vector<std::string> ::const_iterator _iter1000; + for (_iter1000 = this->tbl_names.begin(); _iter1000 != this->tbl_names.end(); ++_iter1000) { - xfer += oprot->writeString((*_iter999)); + xfer += oprot->writeString((*_iter1000)); } xfer += oprot->writeListEnd(); } @@ -7346,10 +7346,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 _iter1000; - for (_iter1000 = (*(this->tbl_names)).begin(); _iter1000 != (*(this->tbl_names)).end(); ++_iter1000) + std::vector<std::string> ::const_iterator _iter1001; + for (_iter1001 = (*(this->tbl_names)).begin(); _iter1001 != (*(this->tbl_names)).end(); ++_iter1001) { - xfer += oprot->writeString((*_iter1000)); + xfer += oprot->writeString((*_iter1001)); } xfer += oprot->writeListEnd(); } @@ -7390,14 +7390,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 _size1001; - ::apache::thrift::protocol::TType _etype1004; - xfer += iprot->readListBegin(_etype1004, _size1001); - this->success.resize(_size1001); - uint32_t _i1005; - for (_i1005 = 0; _i1005 < _size1001; ++_i1005) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + this->success.resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += this->success[_i1005].read(iprot); + xfer += this->success[_i1006].read(iprot); } xfer += iprot->readListEnd(); } @@ -7428,10 +7428,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 _iter1006; - for (_iter1006 = this->success.begin(); _iter1006 != this->success.end(); ++_iter1006) + std::vector<Table> ::const_iterator _iter1007; + for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007) { - xfer += (*_iter1006).write(oprot); + xfer += (*_iter1007).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7472,14 +7472,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 _size1007; - ::apache::thrift::protocol::TType _etype1010; - xfer += iprot->readListBegin(_etype1010, _size1007); - (*(this->success)).resize(_size1007); - uint32_t _i1011; - for (_i1011 = 0; _i1011 < _size1007; ++_i1011) + uint32_t _size1008; + ::apache::thrift::protocol::TType _etype1011; + xfer += iprot->readListBegin(_etype1011, _size1008); + (*(this->success)).resize(_size1008); + uint32_t _i1012; + for (_i1012 = 0; _i1012 < _size1008; ++_i1012) { - xfer += (*(this->success))[_i1011].read(iprot); + xfer += (*(this->success))[_i1012].read(iprot); } xfer += iprot->readListEnd(); } @@ -8115,14 +8115,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 _size1012; - ::apache::thrift::protocol::TType _etype1015; - xfer += iprot->readListBegin(_etype1015, _size1012); - this->success.resize(_size1012); - uint32_t _i1016; - for (_i1016 = 0; _i1016 < _size1012; ++_i1016) + uint32_t _size1013; + ::apache::thrift::protocol::TType _etype1016; + xfer += iprot->readListBegin(_etype1016, _size1013); + this->success.resize(_size1013); + uint32_t _i1017; + for (_i1017 = 0; _i1017 < _size1013; ++_i1017) { - xfer += iprot->readString(this->success[_i1016]); + xfer += iprot->readString(this->success[_i1017]); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,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 _iter1017; - for (_iter1017 = this->success.begin(); _iter1017 != this->success.end(); ++_iter1017) + std::vector<std::string> ::const_iterator _iter1018; + for (_iter1018 = this->success.begin(); _iter1018 != this->success.end(); ++_iter1018) { - xfer += oprot->writeString((*_iter1017)); + xfer += oprot->writeString((*_iter1018)); } xfer += oprot->writeListEnd(); } @@ -8233,14 +8233,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 _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - (*(this->success)).resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1019; + ::apache::thrift::protocol::TType _etype1022; + xfer += iprot->readListBegin(_etype1022, _size1019); + (*(this->success)).resize(_size1019); + uint32_t _i1023; + for (_i1023 = 0; _i1023 < _size1019; ++_i1023) { - xfer += iprot->readString((*(this->success))[_i1022]); + xfer += iprot->readString((*(this->success))[_i1023]); } xfer += iprot->readListEnd(); } @@ -9574,14 +9574,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1023; - ::apache::thrift::protocol::TType _etype1026; - xfer += iprot->readListBegin(_etype1026, _size1023); - this->new_parts.resize(_size1023); - uint32_t _i1027; - for (_i1027 = 0; _i1027 < _size1023; ++_i1027) + uint32_t _size1024; + ::apache::thrift::protocol::TType _etype1027; + xfer += iprot->readListBegin(_etype1027, _size1024); + this->new_parts.resize(_size1024); + uint32_t _i1028; + for (_i1028 = 0; _i1028 < _size1024; ++_i1028) { - xfer += this->new_parts[_i1027].read(iprot); + xfer += this->new_parts[_i1028].read(iprot); } xfer += iprot->readListEnd(); } @@ -9610,10 +9610,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 _iter1028; - for (_iter1028 = this->new_parts.begin(); _iter1028 != this->new_parts.end(); ++_iter1028) + std::vector<Partition> ::const_iterator _iter1029; + for (_iter1029 = this->new_parts.begin(); _iter1029 != this->new_parts.end(); ++_iter1029) { - xfer += (*_iter1028).write(oprot); + xfer += (*_iter1029).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9637,10 +9637,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 _iter1029; - for (_iter1029 = (*(this->new_parts)).begin(); _iter1029 != (*(this->new_parts)).end(); ++_iter1029) + std::vector<Partition> ::const_iterator _iter1030; + for (_iter1030 = (*(this->new_parts)).begin(); _iter1030 != (*(this->new_parts)).end(); ++_iter1030) { - xfer += (*_iter1029).write(oprot); + xfer += (*_iter1030).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9849,14 +9849,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 _size1030; - ::apache::thrift::protocol::TType _etype1033; - xfer += iprot->readListBegin(_etype1033, _size1030); - this->new_parts.resize(_size1030); - uint32_t _i1034; - for (_i1034 = 0; _i1034 < _size1030; ++_i1034) + uint32_t _size1031; + ::apache::thrift::protocol::TType _etype1034; + xfer += iprot->readListBegin(_etype1034, _size1031); + this->new_parts.resize(_size1031); + uint32_t _i1035; + for (_i1035 = 0; _i1035 < _size1031; ++_i1035) { - xfer += this->new_parts[_i1034].read(iprot); + xfer += this->new_parts[_i1035].read(iprot); } xfer += iprot->readListEnd(); } @@ -9885,10 +9885,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 _iter1035; - for (_iter1035 = this->new_parts.begin(); _iter1035 != this->new_parts.end(); ++_iter1035) + std::vector<PartitionSpec> ::const_iterator _iter1036; + for (_iter1036 = this->new_parts.begin(); _iter1036 != this->new_parts.end(); ++_iter1036) { - xfer += (*_iter1035).write(oprot); + xfer += (*_iter1036).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9912,10 +9912,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 _iter1036; - for (_iter1036 = (*(this->new_parts)).begin(); _iter1036 != (*(this->new_parts)).end(); ++_iter1036) + std::vector<PartitionSpec> ::const_iterator _iter1037; + for (_iter1037 = (*(this->new_parts)).begin(); _iter1037 != (*(this->new_parts)).end(); ++_iter1037) { - xfer += (*_iter1036).write(oprot); + xfer += (*_iter1037).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10140,14 +10140,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1037; - ::apache::thrift::protocol::TType _etype1040; - xfer += iprot->readListBegin(_etype1040, _size1037); - this->part_vals.resize(_size1037); - uint32_t _i1041; - for (_i1041 = 0; _i1041 < _size1037; ++_i1041) + uint32_t _size1038; + ::apache::thrift::protocol::TType _etype1041; + xfer += iprot->readListBegin(_etype1041, _size1038); + this->part_vals.resize(_size1038); + uint32_t _i1042; + for (_i1042 = 0; _i1042 < _size1038; ++_i1042) { - xfer += iprot->readString(this->part_vals[_i1041]); + xfer += iprot->readString(this->part_vals[_i1042]); } xfer += iprot->readListEnd(); } @@ -10184,10 +10184,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 _iter1042; - for (_iter1042 = this->part_vals.begin(); _iter1042 != this->part_vals.end(); ++_iter1042) + std::vector<std::string> ::const_iterator _iter1043; + for (_iter1043 = this->part_vals.begin(); _iter1043 != this->part_vals.end(); ++_iter1043) { - xfer += oprot->writeString((*_iter1042)); + xfer += oprot->writeString((*_iter1043)); } xfer += oprot->writeListEnd(); } @@ -10219,10 +10219,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 _iter1043; - for (_iter1043 = (*(this->part_vals)).begin(); _iter1043 != (*(this->part_vals)).end(); ++_iter1043) + std::vector<std::string> ::const_iterator _iter1044; + for (_iter1044 = (*(this->part_vals)).begin(); _iter1044 != (*(this->part_vals)).end(); ++_iter1044) { - xfer += oprot->writeString((*_iter1043)); + xfer += oprot->writeString((*_iter1044)); } xfer += oprot->writeListEnd(); } @@ -10694,14 +10694,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1044; - ::apache::thrift::protocol::TType _etype1047; - xfer += iprot->readListBegin(_etype1047, _size1044); - this->part_vals.resize(_size1044); - uint32_t _i1048; - for (_i1048 = 0; _i1048 < _size1044; ++_i1048) + uint32_t _size1045; + ::apache::thrift::protocol::TType _etype1048; + xfer += iprot->readListBegin(_etype1048, _size1045); + this->part_vals.resize(_size1045); + uint32_t _i1049; + for (_i1049 = 0; _i1049 < _size1045; ++_i1049) { - xfer += iprot->readString(this->part_vals[_i1048]); + xfer += iprot->readString(this->part_vals[_i1049]); } xfer += iprot->readListEnd(); } @@ -10746,10 +10746,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 _iter1049; - for (_iter1049 = this->part_vals.begin(); _iter1049 != this->part_vals.end(); ++_iter1049) + std::vector<std::string> ::const_iterator _iter1050; + for (_iter1050 = this->part_vals.begin(); _iter1050 != this->part_vals.end(); ++_iter1050) { - xfer += oprot->writeString((*_iter1049)); + xfer += oprot->writeString((*_iter1050)); } xfer += oprot->writeListEnd(); } @@ -10785,10 +10785,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 _iter1050; - for (_iter1050 = (*(this->part_vals)).begin(); _iter1050 != (*(this->part_vals)).end(); ++_iter1050) + std::vector<std::string> ::const_iterator _iter1051; + for (_iter1051 = (*(this->part_vals)).begin(); _iter1051 != (*(this->part_vals)).end(); ++_iter1051) { - xfer += oprot->writeString((*_iter1050)); + xfer += oprot->writeString((*_iter1051)); } xfer += oprot->writeListEnd(); } @@ -11591,14 +11591,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - this->part_vals.resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1052; + ::apache::thrift::protocol::TType _etype1055; + xfer += iprot->readListBegin(_etype1055, _size1052); + this->part_vals.resize(_size1052); + uint32_t _i1056; + for (_i1056 = 0; _i1056 < _size1052; ++_i1056) { - xfer += iprot->readString(this->part_vals[_i1055]); + xfer += iprot->readString(this->part_vals[_i1056]); } xfer += iprot->readListEnd(); } @@ -11643,10 +11643,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 _iter1056; - for (_iter1056 = this->part_vals.begin(); _iter1056 != this->part_vals.end(); ++_iter1056) + std::vector<std::string> ::const_iterator _iter1057; + for (_iter1057 = this->part_vals.begin(); _iter1057 != this->part_vals.end(); ++_iter1057) { - xfer += oprot->writeString((*_iter1056)); + xfer += oprot->writeString((*_iter1057)); } xfer += oprot->writeListEnd(); } @@ -11682,10 +11682,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 _iter1057; - for (_iter1057 = (*(this->part_vals)).begin(); _iter1057 != (*(this->part_vals)).end(); ++_iter1057) + std::vector<std::string> ::const_iterator _iter1058; + for (_iter1058 = (*(this->part_vals)).begin(); _iter1058 != (*(this->part_vals)).end(); ++_iter1058) { - xfer += oprot->writeString((*_iter1057)); + xfer += oprot->writeString((*_iter1058)); } xfer += oprot->writeListEnd(); } @@ -11894,14 +11894,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1058; - ::apache::thrift::protocol::TType _etype1061; - xfer += iprot->readListBegin(_etype1061, _size1058); - this->part_vals.resize(_size1058); - uint32_t _i1062; - for (_i1062 = 0; _i1062 < _size1058; ++_i1062) + uint32_t _size1059; + ::apache::thrift::protocol::TType _etype1062; + xfer += iprot->readListBegin(_etype1062, _size1059); + this->part_vals.resize(_size1059); + uint32_t _i1063; + for (_i1063 = 0; _i1063 < _size1059; ++_i1063) { - xfer += iprot->readString(this->part_vals[_i1062]); + xfer += iprot->readString(this->part_vals[_i1063]); } xfer += iprot->readListEnd(); } @@ -11954,10 +11954,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 _iter1063; - for (_iter1063 = this->part_vals.begin(); _iter1063 != this->part_vals.end(); ++_iter1063) + std::vector<std::string> ::const_iterator _iter1064; + for (_iter1064 = this->part_vals.begin(); _iter1064 != this->part_vals.end(); ++_iter1064) { - xfer += oprot->writeString((*_iter1063)); + xfer += oprot->writeString((*_iter1064)); } xfer += oprot->writeListEnd(); } @@ -11997,10 +11997,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 _iter1064; - for (_iter1064 = (*(this->part_vals)).begin(); _iter1064 != (*(this->part_vals)).end(); ++_iter1064) + std::vector<std::string> ::const_iterator _iter1065; + for (_iter1065 = (*(this->part_vals)).begin(); _iter1065 != (*(this->part_vals)).end(); ++_iter1065) { - xfer += oprot->writeString((*_iter1064)); + xfer += oprot->writeString((*_iter1065)); } xfer += oprot->writeListEnd(); } @@ -13006,14 +13006,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1065; - ::apache::thrift::protocol::TType _etype1068; - xfer += iprot->readListBegin(_etype1068, _size1065); - this->part_vals.resize(_size1065); - uint32_t _i1069; - for (_i1069 = 0; _i1069 < _size1065; ++_i1069) + uint32_t _size1066; + ::apache::thrift::protocol::TType _etype1069; + xfer += iprot->readListBegin(_etype1069, _size1066); + this->part_vals.resize(_size1066); + uint32_t _i1070; + for (_i1070 = 0; _i1070 < _size1066; ++_i1070) { - xfer += iprot->readString(this->part_vals[_i1069]); + xfer += iprot->readString(this->part_vals[_i1070]); } xfer += iprot->readListEnd(); } @@ -13050,10 +13050,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 _iter1070; - for (_iter1070 = this->part_vals.begin(); _iter1070 != this->part_vals.end(); ++_iter1070) + std::vector<std::string> ::const_iterator _iter1071; + for (_iter1071 = this->part_vals.begin(); _iter1071 != this->part_vals.end(); ++_iter1071) { - xfer += oprot->writeString((*_iter1070)); + xfer += oprot->writeString((*_iter1071)); } xfer += oprot->writeListEnd(); } @@ -13085,10 +13085,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 _iter1071; - for (_iter1071 = (*(this->part_vals)).begin(); _iter1071 != (*(this->part_vals)).end(); ++_iter1071) + std::vector<std::string> ::const_iterator _iter1072; + for (_iter1072 = (*(this->part_vals)).begin(); _iter1072 != (*(this->part_vals)).end(); ++_iter1072) { - xfer += oprot->writeString((*_iter1071)); + xfer += oprot->writeString((*_iter1072)); } xfer += oprot->writeListEnd(); } @@ -13277,17 +13277,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1072; - ::apache::thrift::protocol::TType _ktype1073; - ::apache::thrift::protocol::TType _vtype1074; - xfer += iprot->readMapBegin(_ktype1073, _vtype1074, _size1072); - uint32_t _i1076; - for (_i1076 = 0; _i1076 < _size1072; ++_i1076) + uint32_t _size1073; + ::apache::thrift::protocol::TType _ktype1074; + ::apache::thrift::protocol::TType _vtype1075; + xfer += iprot->readMapBegin(_ktype1074, _vtype1075, _size1073); + uint32_t _i1077; + for (_i1077 = 0; _i1077 < _size1073; ++_i1077) { - std::string _key1077; - xfer += iprot->readString(_key1077); - std::string& _val1078 = this->partitionSpecs[_key1077]; - xfer += iprot->readString(_val1078); + std::string _key1078; + xfer += iprot->readString(_key1078); + std::string& _val1079 = this->partitionSpecs[_key1078]; + xfer += iprot->readString(_val1079); } xfer += iprot->readMapEnd(); } @@ -13348,11 +13348,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 _iter1079; - for (_iter1079 = this->partitionSpecs.begin(); _iter1079 != this->partitionSpecs.end(); ++_iter1079) + std::map<std::string, std::string> ::const_iterator _iter1080; + for (_iter1080 = this->partitionSpecs.begin(); _iter1080 != this->partitionSpecs.end(); ++_iter1080) { - xfer += oprot->writeString(_iter1079->first); - xfer += oprot->writeString(_iter1079->second); + xfer += oprot->writeString(_iter1080->first); + xfer += oprot->writeString(_iter1080->second); } xfer += oprot->writeMapEnd(); } @@ -13392,11 +13392,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 _iter1080; - for (_iter1080 = (*(this->partitionSpecs)).begin(); _iter1080 != (*(this->partitionSpecs)).end(); ++_iter1080) + std::map<std::string, std::string> ::const_iterator _iter1081; + for (_iter1081 = (*(this->partitionSpecs)).begin(); _iter1081 != (*(this->partitionSpecs)).end(); ++_iter1081) { - xfer += oprot->writeString(_iter1080->first); - xfer += oprot->writeString(_iter1080->second); + xfer += oprot->writeString(_iter1081->first); + xfer += oprot->writeString(_iter1081->second); } xfer += oprot->writeMapEnd(); } @@ -13641,17 +13641,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1081; - ::apache::thrift::protocol::TType _ktype1082; - ::apache::thrift::protocol::TType _vtype1083; - xfer += iprot->readMapBegin(_ktype1082, _vtype1083, _size1081); - uint32_t _i1085; - for (_i1085 = 0; _i1085 < _size1081; ++_i1085) + uint32_t _size1082; + ::apache::thrift::protocol::TType _ktype1083; + ::apache::thrift::protocol::TType _vtype1084; + xfer += iprot->readMapBegin(_ktype1083, _vtype1084, _size1082); + uint32_t _i1086; + for (_i1086 = 0; _i1086 < _size1082; ++_i1086) { - std::string _key1086; - xfer += iprot->readString(_key1086); - std::string& _val1087 = this->partitionSpecs[_key1086]; - xfer += iprot->readString(_val1087); + std::string _key1087; + xfer += iprot->readString(_key1087); + std::string& _val1088 = this->partitionSpecs[_key1087]; + xfer += iprot->readString(_val1088); } xfer += iprot->readMapEnd(); } @@ -13712,11 +13712,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 _iter1088; - for (_iter1088 = this->partitionSpecs.begin(); _iter1088 != this->partitionSpecs.end(); ++_iter1088) + std::map<std::string, std::string> ::const_iterator _iter1089; + for (_iter1089 = this->partitionSpecs.begin(); _iter1089 != this->partitionSpecs.end(); ++_iter1089) { - xfer += oprot->writeString(_iter1088->first); - xfer += oprot->writeString(_iter1088->second); + xfer += oprot->writeString(_iter1089->first); + xfer += oprot->writeString(_iter1089->second); } xfer += oprot->writeMapEnd(); } @@ -13756,11 +13756,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 _iter1089; - for (_iter1089 = (*(this->partitionSpecs)).begin(); _iter1089 != (*(this->partitionSpecs)).end(); ++_iter1089) + std::map<std::string, std::string> ::const_iterator _iter1090; + for (_iter1090 = (*(this->partitionSpecs)).begin(); _iter1090 != (*(this->partitionSpecs)).end(); ++_iter1090) { - xfer += oprot->writeString(_iter1089->first); - xfer += oprot->writeString(_iter1089->second); + xfer += oprot->writeString(_iter1090->first); + xfer += oprot->writeString(_iter1090->second); } xfer += oprot->writeMapEnd(); } @@ -13817,14 +13817,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1090; - ::apache::thrift::protocol::TType _etype1093; - xfer += iprot->readListBegin(_etype1093, _size1090); - this->success.resize(_size1090); - uint32_t _i1094; - for (_i1094 = 0; _i1094 < _size1090; ++_i1094) + uint32_t _size1091; + ::apache::thrift::protocol::TType _etype1094; + xfer += iprot->readListBegin(_etype1094, _size1091); + this->success.resize(_size1091); + uint32_t _i1095; + for (_i1095 = 0; _i1095 < _size1091; ++_i1095) { - xfer += this->success[_i1094].read(iprot); + xfer += this->success[_i1095].read(iprot); } xfer += iprot->readListEnd(); } @@ -13887,10 +13887,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 _iter1095; - for (_iter1095 = this->success.begin(); _iter1095 != this->success.end(); ++_iter1095) + std::vector<Partition> ::const_iterator _iter1096; + for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) { - xfer += (*_iter1095).write(oprot); + xfer += (*_iter1096).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13947,14 +13947,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1096; - ::apache::thrift::protocol::TType _etype1099; - xfer += iprot->readListBegin(_etype1099, _size1096); - (*(this->success)).resize(_size1096); - uint32_t _i1100; - for (_i1100 = 0; _i1100 < _size1096; ++_i1100) + uint32_t _size1097; + ::apache::thrift::protocol::TType _etype1100; + xfer += iprot->readListBegin(_etype1100, _size1097); + (*(this->success)).resize(_size1097); + uint32_t _i1101; + for (_i1101 = 0; _i1101 < _size1097; ++_i1101) { - xfer += (*(this->success))[_i1100].read(iprot); + xfer += (*(this->success))[_i1101].read(iprot); } xfer += iprot->readListEnd(); } @@ -14053,14 +14053,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 _size1101; - ::apache::thrift::protocol::TType _etype1104; - xfer += iprot->readListBegin(_etype1104, _size1101); - this->part_vals.resize(_size1101); - uint32_t _i1105; - for (_i1105 = 0; _i1105 < _size1101; ++_i1105) + uint32_t _size1102; + ::apache::thrift::protocol::TType _etype1105; + xfer += iprot->readListBegin(_etype1105, _size1102); + this->part_vals.resize(_size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - xfer += iprot->readString(this->part_vals[_i1105]); + xfer += iprot->readString(this->part_vals[_i1106]); } xfer += iprot->readListEnd(); } @@ -14081,14 +14081,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 _size1106; - ::apache::thrift::protocol::TType _etype1109; - xfer += iprot->readListBegin(_etype1109, _size1106); - this->group_names.resize(_size1106); - uint32_t _i1110; - for (_i1110 = 0; _i1110 < _size1106; ++_i1110) + uint32_t _size1107; + ::apache::thrift::protocol::TType _etype1110; + xfer += iprot->readListBegin(_etype1110, _size1107); + this->group_names.resize(_size1107); + uint32_t _i1111; + for (_i1111 = 0; _i1111 < _size1107; ++_i1111) { - xfer += iprot->readString(this->group_names[_i1110]); + xfer += iprot->readString(this->group_names[_i1111]); } xfer += iprot->readListEnd(); } @@ -14125,10 +14125,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 _iter1111; - for (_iter1111 = this->part_vals.begin(); _iter1111 != this->part_vals.end(); ++_iter1111) + std::vector<std::string> ::const_iterator _iter1112; + for (_iter1112 = this->part_vals.begin(); _iter1112 != this->part_vals.end(); ++_iter1112) { - xfer += oprot->writeString((*_iter1111)); + xfer += oprot->writeString((*_iter1112)); } xfer += oprot->writeListEnd(); } @@ -14141,10 +14141,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 _iter1112; - for (_iter1112 = this->group_names.begin(); _iter1112 != this->group_names.end(); ++_iter1112) + std::vector<std::string> ::const_iterator _iter1113; + for (_iter1113 = this->group_names.begin(); _iter1113 != this->group_names.end(); ++_iter1113) { - xfer += oprot->writeString((*_iter1112)); + xfer += oprot->writeString((*_iter1113)); } xfer += oprot->writeListEnd(); } @@ -14176,10 +14176,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 _iter1113; - for (_iter1113 = (*(this->part_vals)).begin(); _iter1113 != (*(this->part_vals)).end(); ++_iter1113) + std::vector<std::string> ::const_iterator _iter1114; + for (_iter1114 = (*(this->part_vals)).begin(); _iter1114 != (*(this->part_vals)).end(); ++_iter1114) { - xfer += oprot->writeString((*_iter1113)); + xfer += oprot->writeString((*_iter1114)); } xfer += oprot->writeListEnd(); } @@ -14192,10 +14192,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 _iter1114; - for (_iter1114 = (*(this->group_names)).begin(); _iter1114 != (*(this->group_names)).end(); ++_iter1114) + std::vector<std::string> ::const_iterator _iter1115; + for (_iter1115 = (*(this->group_names)).begin(); _iter1115 != (*(this->group_names)).end(); ++_iter1115) { - xfer += oprot->writeString((*_iter1114)); + xfer += oprot->writeString((*_iter1115)); } xfer += oprot->writeListEnd(); } @@ -14754,14 +14754,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1115; - ::apache::thrift::protocol::TType _etype1118; - xfer += iprot->readListBegin(_etype1118, _size1115); - this->success.resize(_size1115); - uint32_t _i1119; - for (_i1119 = 0; _i1119 < _size1115; ++_i1119) + uint32_t _size1116; + ::apache::thrift::protocol::TType _etype1119; + xfer += iprot->readListBegin(_etype1119, _size1116); + this->success.resize(_size1116); + uint32_t _i1120; + for (_i1120 = 0; _i1120 < _size1116; ++_i1120) { - xfer += this->success[_i1119].read(iprot); + xfer += this->success[_i1120].read(iprot); } xfer += iprot->readListEnd(); } @@ -14808,10 +14808,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 _iter1120; - for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) + std::vector<Partition> ::const_iterator _iter1121; + for (_iter1121 = this->success.begin(); _iter1121 != this->success.end(); ++_iter1121) { - xfer += (*_iter1120).write(oprot); + xfer += (*_iter1121).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14860,14 +14860,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1121; - ::apache::thrift::protocol::TType _etype1124; - xfer += iprot->readListBegin(_etype1124, _size1121); - (*(this->success)).resize(_size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + uint32_t _size1122; + ::apache::thrift::protocol::TType _etype1125; + xfer += iprot->readListBegin(_etype1125, _size1122); + (*(this->success)).resize(_size1122); + uint32_t _i1126; + for (_i1126 = 0; _i1126 < _size1122; ++_i1126) { - xfer += (*(this->success))[_i1125].read(iprot); + xfer += (*(this->success))[_i1126].read(iprot); } xfer += iprot->readListEnd(); } @@ -14966,14 +14966,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 _size1126; - ::apache::thrift::protocol::TType _etype1129; - xfer += iprot->readListBegin(_etype1129, _size1126); - this->group_names.resize(_size1126); - uint32_t _i1130; - for (_i1130 = 0; _i1130 < _size1126; ++_i1130) + uint32_t _size1127; + ::apache::thrift::protocol::TType _etype1130; + xfer += iprot->readListBegin(_etype1130, _size1127); + this->group_names.resize(_size1127); + uint32_t _i1131; + for (_i1131 = 0; _i1131 < _size1127; ++_i1131) { - xfer += iprot->readString(this->group_names[_i1130]); + xfer += iprot->readString(this->group_names[_i1131]); } xfer += iprot->readListEnd(); } @@ -15018,10 +15018,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 _iter1131; - for (_iter1131 = this->group_names.begin(); _iter1131 != this->group_names.end(); ++_iter1131) + std::vector<std::string> ::const_iterator _iter1132; + for (_iter1132 = this->group_names.begin(); _iter1132 != this->group_names.end(); ++_iter1132) { - xfer += oprot->writeString((*_iter1131)); + xfer += oprot->writeString((*_iter1132)); } xfer += oprot->writeListEnd(); } @@ -15061,10 +15061,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 _iter1132; - for (_iter1132 = (*(this->group_names)).begin(); _iter1132 != (*(this->group_names)).end(); ++_iter1132) + std::vector<std::string> ::const_iterator _iter1133; + for (_iter1133 = (*(this->group_names)).begin(); _iter1133 != (*(this->group_names)).end(); ++_iter1133) { - xfer += oprot->writeString((*_iter1132)); + xfer += oprot->writeString((*_iter1133)); } xfer += oprot->writeListEnd(); } @@ -15105,14 +15105,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1133; - ::apache::thrift::protocol::TType _etype1136; - xfer += iprot->readListBegin(_etype1136, _size1133); - this->success.resize(_size1133); - uint32_t _i1137; - for (_i1137 = 0; _i1137 < _size1133; ++_i1137) + uint32_t _size1134; + ::apache::thrift::protocol::TType _etype1137; + xfer += iprot->readListBegin(_etype1137, _size1134); + this->success.resize(_size1134); + uint32_t _i1138; + for (_i1138 = 0; _i1138 < _size1134; ++_i1138) { - xfer += this->success[_i1137].read(iprot); + xfer += this->success[_i1138].read(iprot); } xfer += iprot->readListEnd(); } @@ -15159,10 +15159,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 _iter1138; - for (_iter1138 = this->success.begin(); _iter1138 != this->success.end(); ++_iter1138) + std::vector<Partition> ::const_iterator _iter1139; + for (_iter1139 = this->success.begin(); _iter1139 != this->success.end(); ++_iter1139) { - xfer += (*_iter1138).write(oprot); + xfer += (*_iter1139).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15211,14 +15211,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1139; - ::apache::thrift::protocol::TType _etype1142; - xfer += iprot->readListBegin(_etype1142, _size1139); - (*(this->success)).resize(_size1139); - uint32_t _i1143; - for (_i1143 = 0; _i1143 < _size1139; ++_i1143) + uint32_t _size1140; + ::apache::thrift::protocol::TType _etype1143; + xfer += iprot->readListBegin(_etype1143, _size1140); + (*(this->success)).resize(_size1140); + uint32_t _i1144; + for (_i1144 = 0; _i1144 < _size1140; ++_i1144) { - xfer += (*(this->success))[_i1143].read(iprot); + xfer += (*(this->success))[_i1144].read(iprot); } xfer += iprot->readListEnd(); } @@ -15396,14 +15396,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1144; - ::apache::thrift::protocol::TType _etype1147; - xfer += iprot->readListBegin(_etype1147, _size1144); - this->success.resize(_size1144); - uint32_t _i1148; - for (_i1148 = 0;
<TRUNCATED>
