http://git-wip-us.apache.org/repos/asf/hive/blob/187eb760/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 df49615..4e3b2af 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 _size840; - ::apache::thrift::protocol::TType _etype843; - xfer += iprot->readListBegin(_etype843, _size840); - this->success.resize(_size840); - uint32_t _i844; - for (_i844 = 0; _i844 < _size840; ++_i844) + uint32_t _size839; + ::apache::thrift::protocol::TType _etype842; + xfer += iprot->readListBegin(_etype842, _size839); + this->success.resize(_size839); + uint32_t _i843; + for (_i843 = 0; _i843 < _size839; ++_i843) { - xfer += iprot->readString(this->success[_i844]); + xfer += iprot->readString(this->success[_i843]); } 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 _iter845; - for (_iter845 = this->success.begin(); _iter845 != this->success.end(); ++_iter845) + std::vector<std::string> ::const_iterator _iter844; + for (_iter844 = this->success.begin(); _iter844 != this->success.end(); ++_iter844) { - xfer += oprot->writeString((*_iter845)); + xfer += oprot->writeString((*_iter844)); } 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 _size846; - ::apache::thrift::protocol::TType _etype849; - xfer += iprot->readListBegin(_etype849, _size846); - (*(this->success)).resize(_size846); - uint32_t _i850; - for (_i850 = 0; _i850 < _size846; ++_i850) + uint32_t _size845; + ::apache::thrift::protocol::TType _etype848; + xfer += iprot->readListBegin(_etype848, _size845); + (*(this->success)).resize(_size845); + uint32_t _i849; + for (_i849 = 0; _i849 < _size845; ++_i849) { - xfer += iprot->readString((*(this->success))[_i850]); + xfer += iprot->readString((*(this->success))[_i849]); } 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 _size851; - ::apache::thrift::protocol::TType _etype854; - xfer += iprot->readListBegin(_etype854, _size851); - this->success.resize(_size851); - uint32_t _i855; - for (_i855 = 0; _i855 < _size851; ++_i855) + 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[_i855]); + xfer += iprot->readString(this->success[_i854]); } 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 _iter856; - for (_iter856 = this->success.begin(); _iter856 != this->success.end(); ++_iter856) + std::vector<std::string> ::const_iterator _iter855; + for (_iter855 = this->success.begin(); _iter855 != this->success.end(); ++_iter855) { - xfer += oprot->writeString((*_iter856)); + xfer += oprot->writeString((*_iter855)); } 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 _size857; - ::apache::thrift::protocol::TType _etype860; - xfer += iprot->readListBegin(_etype860, _size857); - (*(this->success)).resize(_size857); - uint32_t _i861; - for (_i861 = 0; _i861 < _size857; ++_i861) + 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))[_i861]); + xfer += iprot->readString((*(this->success))[_i860]); } 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 _size862; - ::apache::thrift::protocol::TType _ktype863; - ::apache::thrift::protocol::TType _vtype864; - xfer += iprot->readMapBegin(_ktype863, _vtype864, _size862); - uint32_t _i866; - for (_i866 = 0; _i866 < _size862; ++_i866) + uint32_t _size861; + ::apache::thrift::protocol::TType _ktype862; + ::apache::thrift::protocol::TType _vtype863; + xfer += iprot->readMapBegin(_ktype862, _vtype863, _size861); + uint32_t _i865; + for (_i865 = 0; _i865 < _size861; ++_i865) { - std::string _key867; - xfer += iprot->readString(_key867); - Type& _val868 = this->success[_key867]; - xfer += _val868.read(iprot); + std::string _key866; + xfer += iprot->readString(_key866); + Type& _val867 = this->success[_key866]; + xfer += _val867.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 _iter869; - for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) + std::map<std::string, Type> ::const_iterator _iter868; + for (_iter868 = this->success.begin(); _iter868 != this->success.end(); ++_iter868) { - xfer += oprot->writeString(_iter869->first); - xfer += _iter869->second.write(oprot); + xfer += oprot->writeString(_iter868->first); + xfer += _iter868->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 _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 _size869; + ::apache::thrift::protocol::TType _ktype870; + ::apache::thrift::protocol::TType _vtype871; + xfer += iprot->readMapBegin(_ktype870, _vtype871, _size869); + uint32_t _i873; + for (_i873 = 0; _i873 < _size869; ++_i873) { - std::string _key875; - xfer += iprot->readString(_key875); - Type& _val876 = (*(this->success))[_key875]; - xfer += _val876.read(iprot); + std::string _key874; + xfer += iprot->readString(_key874); + Type& _val875 = (*(this->success))[_key874]; + xfer += _val875.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 _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 _size876; + ::apache::thrift::protocol::TType _etype879; + xfer += iprot->readListBegin(_etype879, _size876); + this->success.resize(_size876); + uint32_t _i880; + for (_i880 = 0; _i880 < _size876; ++_i880) { - xfer += this->success[_i881].read(iprot); + xfer += this->success[_i880].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 _iter882; - for (_iter882 = this->success.begin(); _iter882 != this->success.end(); ++_iter882) + std::vector<FieldSchema> ::const_iterator _iter881; + for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) { - xfer += (*_iter882).write(oprot); + xfer += (*_iter881).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 _size883; - ::apache::thrift::protocol::TType _etype886; - xfer += iprot->readListBegin(_etype886, _size883); - (*(this->success)).resize(_size883); - uint32_t _i887; - for (_i887 = 0; _i887 < _size883; ++_i887) + uint32_t _size882; + ::apache::thrift::protocol::TType _etype885; + xfer += iprot->readListBegin(_etype885, _size882); + (*(this->success)).resize(_size882); + uint32_t _i886; + for (_i886 = 0; _i886 < _size882; ++_i886) { - xfer += (*(this->success))[_i887].read(iprot); + xfer += (*(this->success))[_i886].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 _size888; - ::apache::thrift::protocol::TType _etype891; - xfer += iprot->readListBegin(_etype891, _size888); - this->success.resize(_size888); - uint32_t _i892; - for (_i892 = 0; _i892 < _size888; ++_i892) + uint32_t _size887; + ::apache::thrift::protocol::TType _etype890; + xfer += iprot->readListBegin(_etype890, _size887); + this->success.resize(_size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - xfer += this->success[_i892].read(iprot); + xfer += this->success[_i891].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 _iter893; - for (_iter893 = this->success.begin(); _iter893 != this->success.end(); ++_iter893) + std::vector<FieldSchema> ::const_iterator _iter892; + for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) { - xfer += (*_iter893).write(oprot); + xfer += (*_iter892).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 _size894; - ::apache::thrift::protocol::TType _etype897; - xfer += iprot->readListBegin(_etype897, _size894); - (*(this->success)).resize(_size894); - uint32_t _i898; - for (_i898 = 0; _i898 < _size894; ++_i898) + uint32_t _size893; + ::apache::thrift::protocol::TType _etype896; + xfer += iprot->readListBegin(_etype896, _size893); + (*(this->success)).resize(_size893); + uint32_t _i897; + for (_i897 = 0; _i897 < _size893; ++_i897) { - xfer += (*(this->success))[_i898].read(iprot); + xfer += (*(this->success))[_i897].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 _size899; - ::apache::thrift::protocol::TType _etype902; - xfer += iprot->readListBegin(_etype902, _size899); - this->success.resize(_size899); - uint32_t _i903; - for (_i903 = 0; _i903 < _size899; ++_i903) + uint32_t _size898; + ::apache::thrift::protocol::TType _etype901; + xfer += iprot->readListBegin(_etype901, _size898); + this->success.resize(_size898); + uint32_t _i902; + for (_i902 = 0; _i902 < _size898; ++_i902) { - xfer += this->success[_i903].read(iprot); + xfer += this->success[_i902].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 _iter904; - for (_iter904 = this->success.begin(); _iter904 != this->success.end(); ++_iter904) + std::vector<FieldSchema> ::const_iterator _iter903; + for (_iter903 = this->success.begin(); _iter903 != this->success.end(); ++_iter903) { - xfer += (*_iter904).write(oprot); + xfer += (*_iter903).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 _size905; - ::apache::thrift::protocol::TType _etype908; - xfer += iprot->readListBegin(_etype908, _size905); - (*(this->success)).resize(_size905); - uint32_t _i909; - for (_i909 = 0; _i909 < _size905; ++_i909) + uint32_t _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + (*(this->success)).resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += (*(this->success))[_i909].read(iprot); + xfer += (*(this->success))[_i908].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 _size910; - ::apache::thrift::protocol::TType _etype913; - xfer += iprot->readListBegin(_etype913, _size910); - this->success.resize(_size910); - uint32_t _i914; - for (_i914 = 0; _i914 < _size910; ++_i914) + uint32_t _size909; + ::apache::thrift::protocol::TType _etype912; + xfer += iprot->readListBegin(_etype912, _size909); + this->success.resize(_size909); + uint32_t _i913; + for (_i913 = 0; _i913 < _size909; ++_i913) { - xfer += this->success[_i914].read(iprot); + xfer += this->success[_i913].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 _iter915; - for (_iter915 = this->success.begin(); _iter915 != this->success.end(); ++_iter915) + std::vector<FieldSchema> ::const_iterator _iter914; + for (_iter914 = this->success.begin(); _iter914 != this->success.end(); ++_iter914) { - xfer += (*_iter915).write(oprot); + xfer += (*_iter914).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 _size916; - ::apache::thrift::protocol::TType _etype919; - xfer += iprot->readListBegin(_etype919, _size916); - (*(this->success)).resize(_size916); - uint32_t _i920; - for (_i920 = 0; _i920 < _size916; ++_i920) + uint32_t _size915; + ::apache::thrift::protocol::TType _etype918; + xfer += iprot->readListBegin(_etype918, _size915); + (*(this->success)).resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += (*(this->success))[_i920].read(iprot); + xfer += (*(this->success))[_i919].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 _size921; - ::apache::thrift::protocol::TType _etype924; - xfer += iprot->readListBegin(_etype924, _size921); - this->primaryKeys.resize(_size921); - uint32_t _i925; - for (_i925 = 0; _i925 < _size921; ++_i925) + uint32_t _size920; + ::apache::thrift::protocol::TType _etype923; + xfer += iprot->readListBegin(_etype923, _size920); + this->primaryKeys.resize(_size920); + uint32_t _i924; + for (_i924 = 0; _i924 < _size920; ++_i924) { - xfer += this->primaryKeys[_i925].read(iprot); + xfer += this->primaryKeys[_i924].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 _size926; - ::apache::thrift::protocol::TType _etype929; - xfer += iprot->readListBegin(_etype929, _size926); - this->foreignKeys.resize(_size926); - uint32_t _i930; - for (_i930 = 0; _i930 < _size926; ++_i930) + uint32_t _size925; + ::apache::thrift::protocol::TType _etype928; + xfer += iprot->readListBegin(_etype928, _size925); + this->foreignKeys.resize(_size925); + uint32_t _i929; + for (_i929 = 0; _i929 < _size925; ++_i929) { - xfer += this->foreignKeys[_i930].read(iprot); + xfer += this->foreignKeys[_i929].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 _iter931; - for (_iter931 = this->primaryKeys.begin(); _iter931 != this->primaryKeys.end(); ++_iter931) + std::vector<SQLPrimaryKey> ::const_iterator _iter930; + for (_iter930 = this->primaryKeys.begin(); _iter930 != this->primaryKeys.end(); ++_iter930) { - xfer += (*_iter931).write(oprot); + xfer += (*_iter930).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 _iter932; - for (_iter932 = this->foreignKeys.begin(); _iter932 != this->foreignKeys.end(); ++_iter932) + std::vector<SQLForeignKey> ::const_iterator _iter931; + for (_iter931 = this->foreignKeys.begin(); _iter931 != this->foreignKeys.end(); ++_iter931) { - xfer += (*_iter932).write(oprot); + xfer += (*_iter931).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 _iter933; - for (_iter933 = (*(this->primaryKeys)).begin(); _iter933 != (*(this->primaryKeys)).end(); ++_iter933) + std::vector<SQLPrimaryKey> ::const_iterator _iter932; + for (_iter932 = (*(this->primaryKeys)).begin(); _iter932 != (*(this->primaryKeys)).end(); ++_iter932) { - xfer += (*_iter933).write(oprot); + xfer += (*_iter932).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 _iter934; - for (_iter934 = (*(this->foreignKeys)).begin(); _iter934 != (*(this->foreignKeys)).end(); ++_iter934) + std::vector<SQLForeignKey> ::const_iterator _iter933; + for (_iter933 = (*(this->foreignKeys)).begin(); _iter933 != (*(this->foreignKeys)).end(); ++_iter933) { - xfer += (*_iter934).write(oprot); + xfer += (*_iter933).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5931,6 +5931,253 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(: } +ThriftHiveMetastore_truncate_table_args::~ThriftHiveMetastore_truncate_table_args() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size934; + ::apache::thrift::protocol::TType _etype937; + xfer += iprot->readListBegin(_etype937, _size934); + this->partNames.resize(_size934); + uint32_t _i938; + for (_i938 = 0; _i938 < _size934; ++_i938) + { + xfer += iprot->readString(this->partNames[_i938]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_args"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); + std::vector<std::string> ::const_iterator _iter939; + for (_iter939 = this->partNames.begin(); _iter939 != this->partNames.end(); ++_iter939) + { + xfer += oprot->writeString((*_iter939)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_pargs::~ThriftHiveMetastore_truncate_table_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_pargs"); + + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size())); + std::vector<std::string> ::const_iterator _iter940; + for (_iter940 = (*(this->partNames)).begin(); _iter940 != (*(this->partNames)).end(); ++_iter940) + { + xfer += oprot->writeString((*_iter940)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_result::~ThriftHiveMetastore_truncate_table_result() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_truncate_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_truncate_table_presult::~ThriftHiveMetastore_truncate_table_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { } @@ -6055,14 +6302,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->success.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size941; + ::apache::thrift::protocol::TType _etype944; + xfer += iprot->readListBegin(_etype944, _size941); + this->success.resize(_size941); + uint32_t _i945; + for (_i945 = 0; _i945 < _size941; ++_i945) { - xfer += iprot->readString(this->success[_i939]); + xfer += iprot->readString(this->success[_i945]); } xfer += iprot->readListEnd(); } @@ -6101,10 +6348,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 _iter940; - for (_iter940 = this->success.begin(); _iter940 != this->success.end(); ++_iter940) + std::vector<std::string> ::const_iterator _iter946; + for (_iter946 = this->success.begin(); _iter946 != this->success.end(); ++_iter946) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter946)); } xfer += oprot->writeListEnd(); } @@ -6149,14 +6396,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - (*(this->success)).resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size947; + ::apache::thrift::protocol::TType _etype950; + xfer += iprot->readListBegin(_etype950, _size947); + (*(this->success)).resize(_size947); + uint32_t _i951; + for (_i951 = 0; _i951 < _size947; ++_i951) { - xfer += iprot->readString((*(this->success))[_i945]); + xfer += iprot->readString((*(this->success))[_i951]); } xfer += iprot->readListEnd(); } @@ -6326,14 +6573,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 _size946; - ::apache::thrift::protocol::TType _etype949; - xfer += iprot->readListBegin(_etype949, _size946); - this->success.resize(_size946); - uint32_t _i950; - for (_i950 = 0; _i950 < _size946; ++_i950) + uint32_t _size952; + ::apache::thrift::protocol::TType _etype955; + xfer += iprot->readListBegin(_etype955, _size952); + this->success.resize(_size952); + uint32_t _i956; + for (_i956 = 0; _i956 < _size952; ++_i956) { - xfer += iprot->readString(this->success[_i950]); + xfer += iprot->readString(this->success[_i956]); } xfer += iprot->readListEnd(); } @@ -6372,10 +6619,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 _iter951; - for (_iter951 = this->success.begin(); _iter951 != this->success.end(); ++_iter951) + std::vector<std::string> ::const_iterator _iter957; + for (_iter957 = this->success.begin(); _iter957 != this->success.end(); ++_iter957) { - xfer += oprot->writeString((*_iter951)); + xfer += oprot->writeString((*_iter957)); } xfer += oprot->writeListEnd(); } @@ -6420,14 +6667,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size952; - ::apache::thrift::protocol::TType _etype955; - xfer += iprot->readListBegin(_etype955, _size952); - (*(this->success)).resize(_size952); - uint32_t _i956; - for (_i956 = 0; _i956 < _size952; ++_i956) + uint32_t _size958; + ::apache::thrift::protocol::TType _etype961; + xfer += iprot->readListBegin(_etype961, _size958); + (*(this->success)).resize(_size958); + uint32_t _i962; + for (_i962 = 0; _i962 < _size958; ++_i962) { - xfer += iprot->readString((*(this->success))[_i956]); + xfer += iprot->readString((*(this->success))[_i962]); } xfer += iprot->readListEnd(); } @@ -6502,14 +6749,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 _size957; - ::apache::thrift::protocol::TType _etype960; - xfer += iprot->readListBegin(_etype960, _size957); - this->tbl_types.resize(_size957); - uint32_t _i961; - for (_i961 = 0; _i961 < _size957; ++_i961) + uint32_t _size963; + ::apache::thrift::protocol::TType _etype966; + xfer += iprot->readListBegin(_etype966, _size963); + this->tbl_types.resize(_size963); + uint32_t _i967; + for (_i967 = 0; _i967 < _size963; ++_i967) { - xfer += iprot->readString(this->tbl_types[_i961]); + xfer += iprot->readString(this->tbl_types[_i967]); } xfer += iprot->readListEnd(); } @@ -6546,10 +6793,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 _iter962; - for (_iter962 = this->tbl_types.begin(); _iter962 != this->tbl_types.end(); ++_iter962) + std::vector<std::string> ::const_iterator _iter968; + for (_iter968 = this->tbl_types.begin(); _iter968 != this->tbl_types.end(); ++_iter968) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter968)); } xfer += oprot->writeListEnd(); } @@ -6581,10 +6828,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 _iter963; - for (_iter963 = (*(this->tbl_types)).begin(); _iter963 != (*(this->tbl_types)).end(); ++_iter963) + std::vector<std::string> ::const_iterator _iter969; + for (_iter969 = (*(this->tbl_types)).begin(); _iter969 != (*(this->tbl_types)).end(); ++_iter969) { - xfer += oprot->writeString((*_iter963)); + xfer += oprot->writeString((*_iter969)); } xfer += oprot->writeListEnd(); } @@ -6625,14 +6872,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size964; - ::apache::thrift::protocol::TType _etype967; - xfer += iprot->readListBegin(_etype967, _size964); - this->success.resize(_size964); - uint32_t _i968; - for (_i968 = 0; _i968 < _size964; ++_i968) + uint32_t _size970; + ::apache::thrift::protocol::TType _etype973; + xfer += iprot->readListBegin(_etype973, _size970); + this->success.resize(_size970); + uint32_t _i974; + for (_i974 = 0; _i974 < _size970; ++_i974) { - xfer += this->success[_i968].read(iprot); + xfer += this->success[_i974].read(iprot); } xfer += iprot->readListEnd(); } @@ -6671,10 +6918,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 _iter969; - for (_iter969 = this->success.begin(); _iter969 != this->success.end(); ++_iter969) + std::vector<TableMeta> ::const_iterator _iter975; + for (_iter975 = this->success.begin(); _iter975 != this->success.end(); ++_iter975) { - xfer += (*_iter969).write(oprot); + xfer += (*_iter975).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6719,14 +6966,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size970; - ::apache::thrift::protocol::TType _etype973; - xfer += iprot->readListBegin(_etype973, _size970); - (*(this->success)).resize(_size970); - uint32_t _i974; - for (_i974 = 0; _i974 < _size970; ++_i974) + uint32_t _size976; + ::apache::thrift::protocol::TType _etype979; + xfer += iprot->readListBegin(_etype979, _size976); + (*(this->success)).resize(_size976); + uint32_t _i980; + for (_i980 = 0; _i980 < _size976; ++_i980) { - xfer += (*(this->success))[_i974].read(iprot); + xfer += (*(this->success))[_i980].read(iprot); } xfer += iprot->readListEnd(); } @@ -6864,14 +7111,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size975; - ::apache::thrift::protocol::TType _etype978; - xfer += iprot->readListBegin(_etype978, _size975); - this->success.resize(_size975); - uint32_t _i979; - for (_i979 = 0; _i979 < _size975; ++_i979) + uint32_t _size981; + ::apache::thrift::protocol::TType _etype984; + xfer += iprot->readListBegin(_etype984, _size981); + this->success.resize(_size981); + uint32_t _i985; + for (_i985 = 0; _i985 < _size981; ++_i985) { - xfer += iprot->readString(this->success[_i979]); + xfer += iprot->readString(this->success[_i985]); } xfer += iprot->readListEnd(); } @@ -6910,10 +7157,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 _iter980; - for (_iter980 = this->success.begin(); _iter980 != this->success.end(); ++_iter980) + std::vector<std::string> ::const_iterator _iter986; + for (_iter986 = this->success.begin(); _iter986 != this->success.end(); ++_iter986) { - xfer += oprot->writeString((*_iter980)); + xfer += oprot->writeString((*_iter986)); } xfer += oprot->writeListEnd(); } @@ -6958,14 +7205,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size981; - ::apache::thrift::protocol::TType _etype984; - xfer += iprot->readListBegin(_etype984, _size981); - (*(this->success)).resize(_size981); - uint32_t _i985; - for (_i985 = 0; _i985 < _size981; ++_i985) + uint32_t _size987; + ::apache::thrift::protocol::TType _etype990; + xfer += iprot->readListBegin(_etype990, _size987); + (*(this->success)).resize(_size987); + uint32_t _i991; + for (_i991 = 0; _i991 < _size987; ++_i991) { - xfer += iprot->readString((*(this->success))[_i985]); + xfer += iprot->readString((*(this->success))[_i991]); } xfer += iprot->readListEnd(); } @@ -7275,14 +7522,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 _size986; - ::apache::thrift::protocol::TType _etype989; - xfer += iprot->readListBegin(_etype989, _size986); - this->tbl_names.resize(_size986); - uint32_t _i990; - for (_i990 = 0; _i990 < _size986; ++_i990) + uint32_t _size992; + ::apache::thrift::protocol::TType _etype995; + xfer += iprot->readListBegin(_etype995, _size992); + this->tbl_names.resize(_size992); + uint32_t _i996; + for (_i996 = 0; _i996 < _size992; ++_i996) { - xfer += iprot->readString(this->tbl_names[_i990]); + xfer += iprot->readString(this->tbl_names[_i996]); } xfer += iprot->readListEnd(); } @@ -7315,10 +7562,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 _iter991; - for (_iter991 = this->tbl_names.begin(); _iter991 != this->tbl_names.end(); ++_iter991) + std::vector<std::string> ::const_iterator _iter997; + for (_iter997 = this->tbl_names.begin(); _iter997 != this->tbl_names.end(); ++_iter997) { - xfer += oprot->writeString((*_iter991)); + xfer += oprot->writeString((*_iter997)); } xfer += oprot->writeListEnd(); } @@ -7346,10 +7593,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 _iter992; - for (_iter992 = (*(this->tbl_names)).begin(); _iter992 != (*(this->tbl_names)).end(); ++_iter992) + std::vector<std::string> ::const_iterator _iter998; + for (_iter998 = (*(this->tbl_names)).begin(); _iter998 != (*(this->tbl_names)).end(); ++_iter998) { - xfer += oprot->writeString((*_iter992)); + xfer += oprot->writeString((*_iter998)); } xfer += oprot->writeListEnd(); } @@ -7390,14 +7637,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 _size993; - ::apache::thrift::protocol::TType _etype996; - xfer += iprot->readListBegin(_etype996, _size993); - this->success.resize(_size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size999; + ::apache::thrift::protocol::TType _etype1002; + xfer += iprot->readListBegin(_etype1002, _size999); + this->success.resize(_size999); + uint32_t _i1003; + for (_i1003 = 0; _i1003 < _size999; ++_i1003) { - xfer += this->success[_i997].read(iprot); + xfer += this->success[_i1003].read(iprot); } xfer += iprot->readListEnd(); } @@ -7428,10 +7675,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 _iter998; - for (_iter998 = this->success.begin(); _iter998 != this->success.end(); ++_iter998) + std::vector<Table> ::const_iterator _iter1004; + for (_iter1004 = this->success.begin(); _iter1004 != this->success.end(); ++_iter1004) { - xfer += (*_iter998).write(oprot); + xfer += (*_iter1004).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7472,14 +7719,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 _size999; - ::apache::thrift::protocol::TType _etype1002; - xfer += iprot->readListBegin(_etype1002, _size999); - (*(this->success)).resize(_size999); - uint32_t _i1003; - for (_i1003 = 0; _i1003 < _size999; ++_i1003) + uint32_t _size1005; + ::apache::thrift::protocol::TType _etype1008; + xfer += iprot->readListBegin(_etype1008, _size1005); + (*(this->success)).resize(_size1005); + uint32_t _i1009; + for (_i1009 = 0; _i1009 < _size1005; ++_i1009) { - xfer += (*(this->success))[_i1003].read(iprot); + xfer += (*(this->success))[_i1009].read(iprot); } xfer += iprot->readListEnd(); } @@ -8115,14 +8362,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 _size1004; - ::apache::thrift::protocol::TType _etype1007; - xfer += iprot->readListBegin(_etype1007, _size1004); - this->success.resize(_size1004); - uint32_t _i1008; - for (_i1008 = 0; _i1008 < _size1004; ++_i1008) + uint32_t _size1010; + ::apache::thrift::protocol::TType _etype1013; + xfer += iprot->readListBegin(_etype1013, _size1010); + this->success.resize(_size1010); + uint32_t _i1014; + for (_i1014 = 0; _i1014 < _size1010; ++_i1014) { - xfer += iprot->readString(this->success[_i1008]); + xfer += iprot->readString(this->success[_i1014]); } xfer += iprot->readListEnd(); } @@ -8177,10 +8424,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 _iter1009; - for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) + std::vector<std::string> ::const_iterator _iter1015; + for (_iter1015 = this->success.begin(); _iter1015 != this->success.end(); ++_iter1015) { - xfer += oprot->writeString((*_iter1009)); + xfer += oprot->writeString((*_iter1015)); } xfer += oprot->writeListEnd(); } @@ -8233,14 +8480,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 _size1010; - ::apache::thrift::protocol::TType _etype1013; - xfer += iprot->readListBegin(_etype1013, _size1010); - (*(this->success)).resize(_size1010); - uint32_t _i1014; - for (_i1014 = 0; _i1014 < _size1010; ++_i1014) + uint32_t _size1016; + ::apache::thrift::protocol::TType _etype1019; + xfer += iprot->readListBegin(_etype1019, _size1016); + (*(this->success)).resize(_size1016); + uint32_t _i1020; + for (_i1020 = 0; _i1020 < _size1016; ++_i1020) { - xfer += iprot->readString((*(this->success))[_i1014]); + xfer += iprot->readString((*(this->success))[_i1020]); } xfer += iprot->readListEnd(); } @@ -9574,14 +9821,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1015; - ::apache::thrift::protocol::TType _etype1018; - xfer += iprot->readListBegin(_etype1018, _size1015); - this->new_parts.resize(_size1015); - uint32_t _i1019; - for (_i1019 = 0; _i1019 < _size1015; ++_i1019) + uint32_t _size1021; + ::apache::thrift::protocol::TType _etype1024; + xfer += iprot->readListBegin(_etype1024, _size1021); + this->new_parts.resize(_size1021); + uint32_t _i1025; + for (_i1025 = 0; _i1025 < _size1021; ++_i1025) { - xfer += this->new_parts[_i1019].read(iprot); + xfer += this->new_parts[_i1025].read(iprot); } xfer += iprot->readListEnd(); } @@ -9610,10 +9857,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 _iter1020; - for (_iter1020 = this->new_parts.begin(); _iter1020 != this->new_parts.end(); ++_iter1020) + std::vector<Partition> ::const_iterator _iter1026; + for (_iter1026 = this->new_parts.begin(); _iter1026 != this->new_parts.end(); ++_iter1026) { - xfer += (*_iter1020).write(oprot); + xfer += (*_iter1026).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9637,10 +9884,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 _iter1021; - for (_iter1021 = (*(this->new_parts)).begin(); _iter1021 != (*(this->new_parts)).end(); ++_iter1021) + std::vector<Partition> ::const_iterator _iter1027; + for (_iter1027 = (*(this->new_parts)).begin(); _iter1027 != (*(this->new_parts)).end(); ++_iter1027) { - xfer += (*_iter1021).write(oprot); + xfer += (*_iter1027).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9849,14 +10096,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 _size1022; - ::apache::thrift::protocol::TType _etype1025; - xfer += iprot->readListBegin(_etype1025, _size1022); - this->new_parts.resize(_size1022); - uint32_t _i1026; - for (_i1026 = 0; _i1026 < _size1022; ++_i1026) + uint32_t _size1028; + ::apache::thrift::protocol::TType _etype1031; + xfer += iprot->readListBegin(_etype1031, _size1028); + this->new_parts.resize(_size1028); + uint32_t _i1032; + for (_i1032 = 0; _i1032 < _size1028; ++_i1032) { - xfer += this->new_parts[_i1026].read(iprot); + xfer += this->new_parts[_i1032].read(iprot); } xfer += iprot->readListEnd(); } @@ -9885,10 +10132,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 _iter1027; - for (_iter1027 = this->new_parts.begin(); _iter1027 != this->new_parts.end(); ++_iter1027) + std::vector<PartitionSpec> ::const_iterator _iter1033; + for (_iter1033 = this->new_parts.begin(); _iter1033 != this->new_parts.end(); ++_iter1033) { - xfer += (*_iter1027).write(oprot); + xfer += (*_iter1033).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9912,10 +10159,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 _iter1028; - for (_iter1028 = (*(this->new_parts)).begin(); _iter1028 != (*(this->new_parts)).end(); ++_iter1028) + std::vector<PartitionSpec> ::const_iterator _iter1034; + for (_iter1034 = (*(this->new_parts)).begin(); _iter1034 != (*(this->new_parts)).end(); ++_iter1034) { - xfer += (*_iter1028).write(oprot); + xfer += (*_iter1034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10140,14 +10387,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1029; - ::apache::thrift::protocol::TType _etype1032; - xfer += iprot->readListBegin(_etype1032, _size1029); - this->part_vals.resize(_size1029); - uint32_t _i1033; - for (_i1033 = 0; _i1033 < _size1029; ++_i1033) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + this->part_vals.resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += iprot->readString(this->part_vals[_i1033]); + xfer += iprot->readString(this->part_vals[_i1039]); } xfer += iprot->readListEnd(); } @@ -10184,10 +10431,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 _iter1034; - for (_iter1034 = this->part_vals.begin(); _iter1034 != this->part_vals.end(); ++_iter1034) + std::vector<std::string> ::const_iterator _iter1040; + for (_iter1040 = this->part_vals.begin(); _iter1040 != this->part_vals.end(); ++_iter1040) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1040)); } xfer += oprot->writeListEnd(); } @@ -10219,10 +10466,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 _iter1035; - for (_iter1035 = (*(this->part_vals)).begin(); _iter1035 != (*(this->part_vals)).end(); ++_iter1035) + std::vector<std::string> ::const_iterator _iter1041; + for (_iter1041 = (*(this->part_vals)).begin(); _iter1041 != (*(this->part_vals)).end(); ++_iter1041) { - xfer += oprot->writeString((*_iter1035)); + xfer += oprot->writeString((*_iter1041)); } xfer += oprot->writeListEnd(); } @@ -10694,14 +10941,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1036; - ::apache::thrift::protocol::TType _etype1039; - xfer += iprot->readListBegin(_etype1039, _size1036); - this->part_vals.resize(_size1036); - uint32_t _i1040; - for (_i1040 = 0; _i1040 < _size1036; ++_i1040) + uint32_t _size1042; + ::apache::thrift::protocol::TType _etype1045; + xfer += iprot->readListBegin(_etype1045, _size1042); + this->part_vals.resize(_size1042); + uint32_t _i1046; + for (_i1046 = 0; _i1046 < _size1042; ++_i1046) { - xfer += iprot->readString(this->part_vals[_i1040]); + xfer += iprot->readString(this->part_vals[_i1046]); } xfer += iprot->readListEnd(); } @@ -10746,10 +10993,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 _iter1041; - for (_iter1041 = this->part_vals.begin(); _iter1041 != this->part_vals.end(); ++_iter1041) + std::vector<std::string> ::const_iterator _iter1047; + for (_iter1047 = this->part_vals.begin(); _iter1047 != this->part_vals.end(); ++_iter1047) { - xfer += oprot->writeString((*_iter1041)); + xfer += oprot->writeString((*_iter1047)); } xfer += oprot->writeListEnd(); } @@ -10785,10 +11032,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 _iter1042; - for (_iter1042 = (*(this->part_vals)).begin(); _iter1042 != (*(this->part_vals)).end(); ++_iter1042) + std::vector<std::string> ::const_iterator _iter1048; + for (_iter1048 = (*(this->part_vals)).begin(); _iter1048 != (*(this->part_vals)).end(); ++_iter1048) { - xfer += oprot->writeString((*_iter1042)); + xfer += oprot->writeString((*_iter1048)); } xfer += oprot->writeListEnd(); } @@ -11591,14 +11838,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1043; - ::apache::thrift::protocol::TType _etype1046; - xfer += iprot->readListBegin(_etype1046, _size1043); - this->part_vals.resize(_size1043); - uint32_t _i1047; - for (_i1047 = 0; _i1047 < _size1043; ++_i1047) + uint32_t _size1049; + ::apache::thrift::protocol::TType _etype1052; + xfer += iprot->readListBegin(_etype1052, _size1049); + this->part_vals.resize(_size1049); + uint32_t _i1053; + for (_i1053 = 0; _i1053 < _size1049; ++_i1053) { - xfer += iprot->readString(this->part_vals[_i1047]); + xfer += iprot->readString(this->part_vals[_i1053]); } xfer += iprot->readListEnd(); } @@ -11643,10 +11890,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 _iter1048; - for (_iter1048 = this->part_vals.begin(); _iter1048 != this->part_vals.end(); ++_iter1048) + std::vector<std::string> ::const_iterator _iter1054; + for (_iter1054 = this->part_vals.begin(); _iter1054 != this->part_vals.end(); ++_iter1054) { - xfer += oprot->writeString((*_iter1048)); + xfer += oprot->writeString((*_iter1054)); } xfer += oprot->writeListEnd(); } @@ -11682,10 +11929,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 _iter1049; - for (_iter1049 = (*(this->part_vals)).begin(); _iter1049 != (*(this->part_vals)).end(); ++_iter1049) + std::vector<std::string> ::const_iterator _iter1055; + for (_iter1055 = (*(this->part_vals)).begin(); _iter1055 != (*(this->part_vals)).end(); ++_iter1055) { - xfer += oprot->writeString((*_iter1049)); + xfer += oprot->writeString((*_iter1055)); } xfer += oprot->writeListEnd(); } @@ -11894,14 +12141,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1050; - ::apache::thrift::protocol::TType _etype1053; - xfer += iprot->readListBegin(_etype1053, _size1050); - this->part_vals.resize(_size1050); - uint32_t _i1054; - for (_i1054 = 0; _i1054 < _size1050; ++_i1054) + uint32_t _size1056; + ::apache::thrift::protocol::TType _etype1059; + xfer += iprot->readListBegin(_etype1059, _size1056); + this->part_vals.resize(_size1056); + uint32_t _i1060; + for (_i1060 = 0; _i1060 < _size1056; ++_i1060) { - xfer += iprot->readString(this->part_vals[_i1054]); + xfer += iprot->readString(this->part_vals[_i1060]); } xfer += iprot->readListEnd(); } @@ -11954,10 +12201,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 _iter1055; - for (_iter1055 = this->part_vals.begin(); _iter1055 != this->part_vals.end(); ++_iter1055) + std::vector<std::string> ::const_iterator _iter1061; + for (_iter1061 = this->part_vals.begin(); _iter1061 != this->part_vals.end(); ++_iter1061) { - xfer += oprot->writeString((*_iter1055)); + xfer += oprot->writeString((*_iter1061)); } xfer += oprot->writeListEnd(); } @@ -11997,10 +12244,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 _iter1056; - for (_iter1056 = (*(this->part_vals)).begin(); _iter1056 != (*(this->part_vals)).end(); ++_iter1056) + std::vector<std::string> ::const_iterator _iter1062; + for (_iter1062 = (*(this->part_vals)).begin(); _iter1062 != (*(this->part_vals)).end(); ++_iter1062) { - xfer += oprot->writeString((*_iter1056)); + xfer += oprot->writeString((*_iter1062)); } xfer += oprot->writeListEnd(); } @@ -13006,14 +13253,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1057; - ::apache::thrift::protocol::TType _etype1060; - xfer += iprot->readListBegin(_etype1060, _size1057); - this->part_vals.resize(_size1057); - uint32_t _i1061; - for (_i1061 = 0; _i1061 < _size1057; ++_i1061) + uint32_t _size1063; + ::apache::thrift::protocol::TType _etype1066; + xfer += iprot->readListBegin(_etype1066, _size1063); + this->part_vals.resize(_size1063); + uint32_t _i1067; + for (_i1067 = 0; _i1067 < _size1063; ++_i1067) { - xfer += iprot->readString(this->part_vals[_i1061]); + xfer += iprot->readString(this->part_vals[_i1067]); } xfer += iprot->readListEnd(); } @@ -13050,10 +13297,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 _iter1062; - for (_iter1062 = this->part_vals.begin(); _iter1062 != this->part_vals.end(); ++_iter1062) + std::vector<std::string> ::const_iterator _iter1068; + for (_iter1068 = this->part_vals.begin(); _iter1068 != this->part_vals.end(); ++_iter1068) { - xfer += oprot->writeString((*_iter1062)); + xfer += oprot->writeString((*_iter1068)); } xfer += oprot->writeListEnd(); } @@ -13085,10 +13332,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 _iter1063; - for (_iter1063 = (*(this->part_vals)).begin(); _iter1063 != (*(this->part_vals)).end(); ++_iter1063) + std::vector<std::string> ::const_iterator _iter1069; + for (_iter1069 = (*(this->part_vals)).begin(); _iter1069 != (*(this->part_vals)).end(); ++_iter1069) { - xfer += oprot->writeString((*_iter1063)); + xfer += oprot->writeString((*_iter1069)); } xfer += oprot->writeListEnd(); } @@ -13277,17 +13524,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1064; - ::apache::thrift::protocol::TType _ktype1065; - ::apache::thrift::protocol::TType _vtype1066; - xfer += iprot->readMapBegin(_ktype1065, _vtype1066, _size1064); - uint32_t _i1068; - for (_i1068 = 0; _i1068 < _size1064; ++_i1068) + uint32_t _size1070; + ::apache::thrift::protocol::TType _ktype1071; + ::apache::thrift::protocol::TType _vtype1072; + xfer += iprot->readMapBegin(_ktype1071, _vtype1072, _size1070); + uint32_t _i1074; + for (_i1074 = 0; _i1074 < _size1070; ++_i1074) { - std::string _key1069; - xfer += iprot->readString(_key1069); - std::string& _val1070 = this->partitionSpecs[_key1069]; - xfer += iprot->readString(_val1070); + std::string _key1075; + xfer += iprot->readString(_key1075); + std::string& _val1076 = this->partitionSpecs[_key1075]; + xfer += iprot->readString(_val1076); } xfer += iprot->readMapEnd(); } @@ -13348,11 +13595,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 _iter1071; - for (_iter1071 = this->partitionSpecs.begin(); _iter1071 != this->partitionSpecs.end(); ++_iter1071) + std::map<std::string, std::string> ::const_iterator _iter1077; + for (_iter1077 = this->partitionSpecs.begin(); _iter1077 != this->partitionSpecs.end(); ++_iter1077) { - xfer += oprot->writeString(_iter1071->first); - xfer += oprot->writeString(_iter1071->second); + xfer += oprot->writeString(_iter1077->first); + xfer += oprot->writeString(_iter1077->second); } xfer += oprot->writeMapEnd(); } @@ -13392,11 +13639,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 _iter1072; - for (_iter1072 = (*(this->partitionSpecs)).begin(); _iter1072 != (*(this->partitionSpecs)).end(); ++_iter1072) + std::map<std::string, std::string> ::const_iterator _iter1078; + for (_iter1078 = (*(this->partitionSpecs)).begin(); _iter1078 != (*(this->partitionSpecs)).end(); ++_iter1078) { - xfer += oprot->writeString(_iter1072->first); - xfer += oprot->writeString(_iter1072->second); + xfer += oprot->writeString(_iter1078->first); + xfer += oprot->writeString(_iter1078->second); } xfer += oprot->writeMapEnd(); } @@ -13641,17 +13888,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - 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) + uint32_t _size1079; + ::apache::thrift::protocol::TType _ktype1080; + ::apache::thrift::protocol::TType _vtype1081; + xfer += iprot->readMapBegin(_ktype1080, _vtype1081, _size1079); + uint32_t _i1083; + for (_i1083 = 0; _i1083 < _size1079; ++_i1083) { - std::string _key1078; - xfer += iprot->readString(_key1078); - std::string& _val1079 = this->partitionSpecs[_key1078]; - xfer += iprot->readString(_val1079); + std::string _key1084; + xfer += iprot->readString(_key1084); + std::string& _val1085 = this->partitionSpecs[_key1084]; + xfer += iprot->readString(_val1085); } xfer += iprot->readMapEnd(); } @@ -13712,11 +13959,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 _iter1080; - for (_iter1080 = this->partitionSpecs.begin(); _iter1080 != this->partitionSpecs.end(); ++_iter1080) + std::map<std::string, std::string> ::const_iterator _iter1086; + for (_iter1086 = this->partitionSpecs.begin(); _iter1086 != this->partitionSpecs.end(); ++_iter1086) { - xfer += oprot->writeString(_iter1080->first); - xfer += oprot->writeString(_iter1080->second); + xfer += oprot->writeString(_iter1086->first); + xfer += oprot->writeString(_iter1086->second); } xfer += oprot->writeMapEnd(); } @@ -13756,11 +14003,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 _iter1081; - for (_iter1081 = (*(this->partitionSpecs)).begin(); _iter1081 != (*(this->partitionSpecs)).end(); ++_iter1081) + std::map<std::string, std::string> ::const_iterator _iter1087; + for (_iter1087 = (*(this->partitionSpecs)).begin(); _iter1087 != (*(this->partitionSpecs)).end(); ++_iter1087) { - xfer += oprot->writeString(_iter1081->first); - xfer += oprot->writeString(_iter1081->second); + xfer += oprot->writeString(_iter1087->first); + xfer += oprot->writeString(_iter1087->second); } xfer += oprot->writeMapEnd(); } @@ -13817,14 +14064,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1082; - ::apache::thrift::protocol::TType _etype1085; - xfer += iprot->readListBegin(_etype1085, _size1082); - this->success.resize(_size1082); - uint32_t _i1086; - for (_i1086 = 0; _i1086 < _size1082; ++_i1086) + uint32_t _size1088; + ::apache::thrift::protocol::TType _etype1091; + xfer += iprot->readListBegin(_etype1091, _size1088); + this->success.resize(_size1088); + uint32_t _i1092; + for (_i1092 = 0; _i1092 < _size1088; ++_i1092) { - xfer += this->success[_i1086].read(iprot); + xfer += this->success[_i1092].read(iprot); } xfer += iprot->readListEnd(); } @@ -13887,10 +14134,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 _iter1087; - for (_iter1087 = this->success.begin(); _iter1087 != this->success.end(); ++_iter1087) + std::vector<Partition> ::const_iterator _iter1093; + for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) { - xfer += (*_iter1087).write(oprot); + xfer += (*_iter1093).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13947,14 +14194,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - (*(this->success)).resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1094; + ::apache::thrift::protocol::TType _etype1097; + xfer += iprot->readListBegin(_etype1097, _size1094); + (*(this->success)).resize(_size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - xfer += (*(this->success))[_i1092].read(iprot); + xfer += (*(this->success))[_i1098].read(iprot); } xfer += iprot->readListEnd(); } @@ -14053,14 +14300,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 _size1093; - ::apache::thrift::protocol::TType _etype1096; - xfer += iprot->readListBegin(_etype1096, _size1093); - this->part_vals.resize(_size1093); - uint32_t _i1097; - for (_i1097 = 0; _i1097 < _size1093; ++_i1097) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->part_vals.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += iprot->readString(this->part_vals[_i1097]); + xfer += iprot->readString(this->part_vals[_i1103]); } xfer += iprot->readListEnd(); } @@ -14081,14 +14328,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 _size1098; - ::apache::thrift::protocol::TType _etype1101; - xfer += iprot->readListBegin(_etype1101, _size1098); - this->group_names.resize(_size1098); - uint32_t _i1102; - for (_i1102 = 0; _i1102 < _size1098; ++_i1102) + uint32_t _size1104; + ::apache::thrift::protocol::TType _etype1107; + xfer += iprot->readListBegin(_etype1107, _size1104); + this->group_names.resize(_size1104); + uint32_t _i1108; + for (_i1108 = 0; _i1108 < _size1104; ++_i1108) { - xfer += iprot->readString(this->group_names[_i1102]); + xfer += iprot->readString(this->group_names[_i1108]); } xfer += iprot->readListEnd(); } @@ -14125,10 +14372,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 _iter1103; - for (_iter1103 = this->part_vals.begin(); _iter1103 != this->part_vals.end(); ++_iter1103) + std::vector<std::string> ::const_iterator _iter1109; + for (_iter1109 = this->part_vals.begin(); _iter1109 != this->part_vals.end(); ++_iter1109) { - xfer += oprot->writeString((*_iter1103)); + xfer += oprot->writeString((*_iter1109)); } xfer += oprot->writeListEnd(); } @@ -14141,10 +14388,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 _iter1104; - for (_iter1104 = this->group_names.begin(); _iter1104 != this->group_names.end(); ++_iter1104) + std::vector<std::string> ::const_iterator _iter1110; + for (_iter1110 = this->group_names.begin(); _iter1110 != this->group_names.end(); ++_iter1110) { - xfer += oprot->writeString((*_iter1104)); + xfer += oprot->writeString((*_iter1110)); } xfer += oprot->writeListEnd(); } @@ -14176,10 +14423,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 _iter1105; - for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) + std::vector<std::string> ::const_iterator _iter1111; + for (_iter1111 = (*(this->part_vals)).begin(); _iter1111 != (*(this->part_vals)).end(); ++_iter1111) { - xfer += oprot->writeString((*_iter1105)); + xfer += oprot->writeString((*_iter1111)); } xfer += oprot->writeListEnd(); } @@ -14192,10 +14439,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 _iter1106; - for (_iter1106 = (*(this->group_names)).begin(); _iter1106 != (*(this->group_names)).end(); ++_iter1106) + std::vector<std::string> ::const_iterator _iter1112; + for (_iter1112 = (*(this->group_names)).begin(); _iter1112 != (*(this->group_names)).end(); ++_iter1112) { - xfer += oprot->writeString((*_iter1106)); + xfer += oprot->writeString((*_iter1112)); } xfer += oprot->writeListEnd(); } @@ -14754,14 +15001,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1107; - ::apache::thrift::protocol::TType _etype1110; - xfer += iprot->readListBegin(_etype1110, _size1107); - this->success.resize(_size1107); - uint32_t _i1111; - for (_i1111 = 0; _i1111 < _size1107; ++_i1111) + uint32_t _size1113; + ::apache::thrift::protocol::TType _etype1116; + xfer += iprot->readListBegin(_etype1116, _size1113); + this->success.resize(_size1113); + uint32_t _i1117; + for (_i1117 = 0; _i1117 < _size1113; ++_i1117) { - xfer += this->success[_i1111].read(iprot); + xfer += this->success[_i1117].read(iprot); } xfer += iprot->readListEnd(); } @@ -14808,10 +15055,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
<TRUNCATED>
