http://git-wip-us.apache.org/repos/asf/hive/blob/f25b8652/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 618c3ac..298384c 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 _size771; - ::apache::thrift::protocol::TType _etype774; - xfer += iprot->readListBegin(_etype774, _size771); - this->success.resize(_size771); - uint32_t _i775; - for (_i775 = 0; _i775 < _size771; ++_i775) + uint32_t _size773; + ::apache::thrift::protocol::TType _etype776; + xfer += iprot->readListBegin(_etype776, _size773); + this->success.resize(_size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - xfer += iprot->readString(this->success[_i775]); + xfer += iprot->readString(this->success[_i777]); } 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 _iter776; - for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776) + std::vector<std::string> ::const_iterator _iter778; + for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) { - xfer += oprot->writeString((*_iter776)); + xfer += oprot->writeString((*_iter778)); } 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 _size777; - ::apache::thrift::protocol::TType _etype780; - xfer += iprot->readListBegin(_etype780, _size777); - (*(this->success)).resize(_size777); - uint32_t _i781; - for (_i781 = 0; _i781 < _size777; ++_i781) + uint32_t _size779; + ::apache::thrift::protocol::TType _etype782; + xfer += iprot->readListBegin(_etype782, _size779); + (*(this->success)).resize(_size779); + uint32_t _i783; + for (_i783 = 0; _i783 < _size779; ++_i783) { - xfer += iprot->readString((*(this->success))[_i781]); + xfer += iprot->readString((*(this->success))[_i783]); } 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 _size782; - ::apache::thrift::protocol::TType _etype785; - xfer += iprot->readListBegin(_etype785, _size782); - this->success.resize(_size782); - uint32_t _i786; - for (_i786 = 0; _i786 < _size782; ++_i786) + uint32_t _size784; + ::apache::thrift::protocol::TType _etype787; + xfer += iprot->readListBegin(_etype787, _size784); + this->success.resize(_size784); + uint32_t _i788; + for (_i788 = 0; _i788 < _size784; ++_i788) { - xfer += iprot->readString(this->success[_i786]); + xfer += iprot->readString(this->success[_i788]); } 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 _iter787; - for (_iter787 = this->success.begin(); _iter787 != this->success.end(); ++_iter787) + std::vector<std::string> ::const_iterator _iter789; + for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) { - xfer += oprot->writeString((*_iter787)); + xfer += oprot->writeString((*_iter789)); } 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 _size788; - ::apache::thrift::protocol::TType _etype791; - xfer += iprot->readListBegin(_etype791, _size788); - (*(this->success)).resize(_size788); - uint32_t _i792; - for (_i792 = 0; _i792 < _size788; ++_i792) + uint32_t _size790; + ::apache::thrift::protocol::TType _etype793; + xfer += iprot->readListBegin(_etype793, _size790); + (*(this->success)).resize(_size790); + uint32_t _i794; + for (_i794 = 0; _i794 < _size790; ++_i794) { - xfer += iprot->readString((*(this->success))[_i792]); + xfer += iprot->readString((*(this->success))[_i794]); } 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 _size793; - ::apache::thrift::protocol::TType _ktype794; - ::apache::thrift::protocol::TType _vtype795; - xfer += iprot->readMapBegin(_ktype794, _vtype795, _size793); - uint32_t _i797; - for (_i797 = 0; _i797 < _size793; ++_i797) + uint32_t _size795; + ::apache::thrift::protocol::TType _ktype796; + ::apache::thrift::protocol::TType _vtype797; + xfer += iprot->readMapBegin(_ktype796, _vtype797, _size795); + uint32_t _i799; + for (_i799 = 0; _i799 < _size795; ++_i799) { - std::string _key798; - xfer += iprot->readString(_key798); - Type& _val799 = this->success[_key798]; - xfer += _val799.read(iprot); + std::string _key800; + xfer += iprot->readString(_key800); + Type& _val801 = this->success[_key800]; + xfer += _val801.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 _iter800; - for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) + std::map<std::string, Type> ::const_iterator _iter802; + for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) { - xfer += oprot->writeString(_iter800->first); - xfer += _iter800->second.write(oprot); + xfer += oprot->writeString(_iter802->first); + xfer += _iter802->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 _size801; - ::apache::thrift::protocol::TType _ktype802; - ::apache::thrift::protocol::TType _vtype803; - xfer += iprot->readMapBegin(_ktype802, _vtype803, _size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size803; + ::apache::thrift::protocol::TType _ktype804; + ::apache::thrift::protocol::TType _vtype805; + xfer += iprot->readMapBegin(_ktype804, _vtype805, _size803); + uint32_t _i807; + for (_i807 = 0; _i807 < _size803; ++_i807) { - std::string _key806; - xfer += iprot->readString(_key806); - Type& _val807 = (*(this->success))[_key806]; - xfer += _val807.read(iprot); + std::string _key808; + xfer += iprot->readString(_key808); + Type& _val809 = (*(this->success))[_key808]; + xfer += _val809.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 _size808; - ::apache::thrift::protocol::TType _etype811; - xfer += iprot->readListBegin(_etype811, _size808); - this->success.resize(_size808); - uint32_t _i812; - for (_i812 = 0; _i812 < _size808; ++_i812) + uint32_t _size810; + ::apache::thrift::protocol::TType _etype813; + xfer += iprot->readListBegin(_etype813, _size810); + this->success.resize(_size810); + uint32_t _i814; + for (_i814 = 0; _i814 < _size810; ++_i814) { - xfer += this->success[_i812].read(iprot); + xfer += this->success[_i814].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 _iter813; - for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) + std::vector<FieldSchema> ::const_iterator _iter815; + for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) { - xfer += (*_iter813).write(oprot); + xfer += (*_iter815).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 _size814; - ::apache::thrift::protocol::TType _etype817; - xfer += iprot->readListBegin(_etype817, _size814); - (*(this->success)).resize(_size814); - uint32_t _i818; - for (_i818 = 0; _i818 < _size814; ++_i818) + uint32_t _size816; + ::apache::thrift::protocol::TType _etype819; + xfer += iprot->readListBegin(_etype819, _size816); + (*(this->success)).resize(_size816); + uint32_t _i820; + for (_i820 = 0; _i820 < _size816; ++_i820) { - xfer += (*(this->success))[_i818].read(iprot); + xfer += (*(this->success))[_i820].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 _size819; - ::apache::thrift::protocol::TType _etype822; - xfer += iprot->readListBegin(_etype822, _size819); - this->success.resize(_size819); - uint32_t _i823; - for (_i823 = 0; _i823 < _size819; ++_i823) + uint32_t _size821; + ::apache::thrift::protocol::TType _etype824; + xfer += iprot->readListBegin(_etype824, _size821); + this->success.resize(_size821); + uint32_t _i825; + for (_i825 = 0; _i825 < _size821; ++_i825) { - xfer += this->success[_i823].read(iprot); + xfer += this->success[_i825].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 _iter824; - for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) + std::vector<FieldSchema> ::const_iterator _iter826; + for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) { - xfer += (*_iter824).write(oprot); + xfer += (*_iter826).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 _size825; - ::apache::thrift::protocol::TType _etype828; - xfer += iprot->readListBegin(_etype828, _size825); - (*(this->success)).resize(_size825); - uint32_t _i829; - for (_i829 = 0; _i829 < _size825; ++_i829) + uint32_t _size827; + ::apache::thrift::protocol::TType _etype830; + xfer += iprot->readListBegin(_etype830, _size827); + (*(this->success)).resize(_size827); + uint32_t _i831; + for (_i831 = 0; _i831 < _size827; ++_i831) { - xfer += (*(this->success))[_i829].read(iprot); + xfer += (*(this->success))[_i831].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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - this->success.resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size832; + ::apache::thrift::protocol::TType _etype835; + xfer += iprot->readListBegin(_etype835, _size832); + this->success.resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += this->success[_i834].read(iprot); + xfer += this->success[_i836].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 _iter835; - for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835) + std::vector<FieldSchema> ::const_iterator _iter837; + for (_iter837 = this->success.begin(); _iter837 != this->success.end(); ++_iter837) { - xfer += (*_iter835).write(oprot); + xfer += (*_iter837).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 _size836; - ::apache::thrift::protocol::TType _etype839; - xfer += iprot->readListBegin(_etype839, _size836); - (*(this->success)).resize(_size836); - uint32_t _i840; - for (_i840 = 0; _i840 < _size836; ++_i840) + uint32_t _size838; + ::apache::thrift::protocol::TType _etype841; + xfer += iprot->readListBegin(_etype841, _size838); + (*(this->success)).resize(_size838); + uint32_t _i842; + for (_i842 = 0; _i842 < _size838; ++_i842) { - xfer += (*(this->success))[_i840].read(iprot); + xfer += (*(this->success))[_i842].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 _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - this->success.resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + uint32_t _size843; + ::apache::thrift::protocol::TType _etype846; + xfer += iprot->readListBegin(_etype846, _size843); + this->success.resize(_size843); + uint32_t _i847; + for (_i847 = 0; _i847 < _size843; ++_i847) { - xfer += this->success[_i845].read(iprot); + xfer += this->success[_i847].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 _iter846; - for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) + std::vector<FieldSchema> ::const_iterator _iter848; + for (_iter848 = this->success.begin(); _iter848 != this->success.end(); ++_iter848) { - xfer += (*_iter846).write(oprot); + xfer += (*_iter848).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 _size847; - ::apache::thrift::protocol::TType _etype850; - xfer += iprot->readListBegin(_etype850, _size847); - (*(this->success)).resize(_size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + 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 += (*(this->success))[_i851].read(iprot); + xfer += (*(this->success))[_i853].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 _size852; - ::apache::thrift::protocol::TType _etype855; - xfer += iprot->readListBegin(_etype855, _size852); - this->primaryKeys.resize(_size852); - uint32_t _i856; - for (_i856 = 0; _i856 < _size852; ++_i856) + uint32_t _size854; + ::apache::thrift::protocol::TType _etype857; + xfer += iprot->readListBegin(_etype857, _size854); + this->primaryKeys.resize(_size854); + uint32_t _i858; + for (_i858 = 0; _i858 < _size854; ++_i858) { - xfer += this->primaryKeys[_i856].read(iprot); + xfer += this->primaryKeys[_i858].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 _size857; - ::apache::thrift::protocol::TType _etype860; - xfer += iprot->readListBegin(_etype860, _size857); - this->foreignKeys.resize(_size857); - uint32_t _i861; - for (_i861 = 0; _i861 < _size857; ++_i861) + uint32_t _size859; + ::apache::thrift::protocol::TType _etype862; + xfer += iprot->readListBegin(_etype862, _size859); + this->foreignKeys.resize(_size859); + uint32_t _i863; + for (_i863 = 0; _i863 < _size859; ++_i863) { - xfer += this->foreignKeys[_i861].read(iprot); + xfer += this->foreignKeys[_i863].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 _iter862; - for (_iter862 = this->primaryKeys.begin(); _iter862 != this->primaryKeys.end(); ++_iter862) + std::vector<SQLPrimaryKey> ::const_iterator _iter864; + for (_iter864 = this->primaryKeys.begin(); _iter864 != this->primaryKeys.end(); ++_iter864) { - xfer += (*_iter862).write(oprot); + xfer += (*_iter864).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 _iter863; - for (_iter863 = this->foreignKeys.begin(); _iter863 != this->foreignKeys.end(); ++_iter863) + std::vector<SQLForeignKey> ::const_iterator _iter865; + for (_iter865 = this->foreignKeys.begin(); _iter865 != this->foreignKeys.end(); ++_iter865) { - xfer += (*_iter863).write(oprot); + xfer += (*_iter865).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 _iter864; - for (_iter864 = (*(this->primaryKeys)).begin(); _iter864 != (*(this->primaryKeys)).end(); ++_iter864) + std::vector<SQLPrimaryKey> ::const_iterator _iter866; + for (_iter866 = (*(this->primaryKeys)).begin(); _iter866 != (*(this->primaryKeys)).end(); ++_iter866) { - xfer += (*_iter864).write(oprot); + xfer += (*_iter866).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 _iter865; - for (_iter865 = (*(this->foreignKeys)).begin(); _iter865 != (*(this->foreignKeys)).end(); ++_iter865) + std::vector<SQLForeignKey> ::const_iterator _iter867; + for (_iter867 = (*(this->foreignKeys)).begin(); _iter867 != (*(this->foreignKeys)).end(); ++_iter867) { - xfer += (*_iter865).write(oprot); + xfer += (*_iter867).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 _size866; - ::apache::thrift::protocol::TType _etype869; - xfer += iprot->readListBegin(_etype869, _size866); - this->success.resize(_size866); - uint32_t _i870; - for (_i870 = 0; _i870 < _size866; ++_i870) + uint32_t _size868; + ::apache::thrift::protocol::TType _etype871; + xfer += iprot->readListBegin(_etype871, _size868); + this->success.resize(_size868); + uint32_t _i872; + for (_i872 = 0; _i872 < _size868; ++_i872) { - xfer += iprot->readString(this->success[_i870]); + xfer += iprot->readString(this->success[_i872]); } 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 _iter871; - for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) + std::vector<std::string> ::const_iterator _iter873; + for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) { - xfer += oprot->writeString((*_iter871)); + xfer += oprot->writeString((*_iter873)); } 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 _size872; - ::apache::thrift::protocol::TType _etype875; - xfer += iprot->readListBegin(_etype875, _size872); - (*(this->success)).resize(_size872); - uint32_t _i876; - for (_i876 = 0; _i876 < _size872; ++_i876) + uint32_t _size874; + ::apache::thrift::protocol::TType _etype877; + xfer += iprot->readListBegin(_etype877, _size874); + (*(this->success)).resize(_size874); + uint32_t _i878; + for (_i878 = 0; _i878 < _size874; ++_i878) { - xfer += iprot->readString((*(this->success))[_i876]); + xfer += iprot->readString((*(this->success))[_i878]); } xfer += iprot->readListEnd(); } @@ -6231,14 +6231,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 _size877; - ::apache::thrift::protocol::TType _etype880; - xfer += iprot->readListBegin(_etype880, _size877); - this->tbl_types.resize(_size877); - uint32_t _i881; - for (_i881 = 0; _i881 < _size877; ++_i881) + uint32_t _size879; + ::apache::thrift::protocol::TType _etype882; + xfer += iprot->readListBegin(_etype882, _size879); + this->tbl_types.resize(_size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - xfer += iprot->readString(this->tbl_types[_i881]); + xfer += iprot->readString(this->tbl_types[_i883]); } xfer += iprot->readListEnd(); } @@ -6275,10 +6275,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 _iter882; - for (_iter882 = this->tbl_types.begin(); _iter882 != this->tbl_types.end(); ++_iter882) + std::vector<std::string> ::const_iterator _iter884; + for (_iter884 = this->tbl_types.begin(); _iter884 != this->tbl_types.end(); ++_iter884) { - xfer += oprot->writeString((*_iter882)); + xfer += oprot->writeString((*_iter884)); } xfer += oprot->writeListEnd(); } @@ -6310,10 +6310,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 _iter883; - for (_iter883 = (*(this->tbl_types)).begin(); _iter883 != (*(this->tbl_types)).end(); ++_iter883) + std::vector<std::string> ::const_iterator _iter885; + for (_iter885 = (*(this->tbl_types)).begin(); _iter885 != (*(this->tbl_types)).end(); ++_iter885) { - xfer += oprot->writeString((*_iter883)); + xfer += oprot->writeString((*_iter885)); } xfer += oprot->writeListEnd(); } @@ -6354,14 +6354,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size884; - ::apache::thrift::protocol::TType _etype887; - xfer += iprot->readListBegin(_etype887, _size884); - this->success.resize(_size884); - uint32_t _i888; - for (_i888 = 0; _i888 < _size884; ++_i888) + 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[_i888].read(iprot); + xfer += this->success[_i890].read(iprot); } xfer += iprot->readListEnd(); } @@ -6400,10 +6400,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 _iter889; - for (_iter889 = this->success.begin(); _iter889 != this->success.end(); ++_iter889) + std::vector<TableMeta> ::const_iterator _iter891; + for (_iter891 = this->success.begin(); _iter891 != this->success.end(); ++_iter891) { - xfer += (*_iter889).write(oprot); + xfer += (*_iter891).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6448,14 +6448,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size890; - ::apache::thrift::protocol::TType _etype893; - xfer += iprot->readListBegin(_etype893, _size890); - (*(this->success)).resize(_size890); - uint32_t _i894; - for (_i894 = 0; _i894 < _size890; ++_i894) + 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))[_i894].read(iprot); + xfer += (*(this->success))[_i896].read(iprot); } xfer += iprot->readListEnd(); } @@ -6593,14 +6593,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size895; - ::apache::thrift::protocol::TType _etype898; - xfer += iprot->readListBegin(_etype898, _size895); - this->success.resize(_size895); - uint32_t _i899; - for (_i899 = 0; _i899 < _size895; ++_i899) + uint32_t _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 += iprot->readString(this->success[_i899]); + xfer += iprot->readString(this->success[_i901]); } xfer += iprot->readListEnd(); } @@ -6639,10 +6639,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 _iter900; - for (_iter900 = this->success.begin(); _iter900 != this->success.end(); ++_iter900) + std::vector<std::string> ::const_iterator _iter902; + for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) { - xfer += oprot->writeString((*_iter900)); + xfer += oprot->writeString((*_iter902)); } xfer += oprot->writeListEnd(); } @@ -6687,14 +6687,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size901; - ::apache::thrift::protocol::TType _etype904; - xfer += iprot->readListBegin(_etype904, _size901); - (*(this->success)).resize(_size901); - uint32_t _i905; - for (_i905 = 0; _i905 < _size901; ++_i905) + 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 += iprot->readString((*(this->success))[_i905]); + xfer += iprot->readString((*(this->success))[_i907]); } xfer += iprot->readListEnd(); } @@ -7004,14 +7004,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 _size906; - ::apache::thrift::protocol::TType _etype909; - xfer += iprot->readListBegin(_etype909, _size906); - this->tbl_names.resize(_size906); - uint32_t _i910; - for (_i910 = 0; _i910 < _size906; ++_i910) + uint32_t _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + this->tbl_names.resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString(this->tbl_names[_i910]); + xfer += iprot->readString(this->tbl_names[_i912]); } xfer += iprot->readListEnd(); } @@ -7044,10 +7044,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 _iter911; - for (_iter911 = this->tbl_names.begin(); _iter911 != this->tbl_names.end(); ++_iter911) + std::vector<std::string> ::const_iterator _iter913; + for (_iter913 = this->tbl_names.begin(); _iter913 != this->tbl_names.end(); ++_iter913) { - xfer += oprot->writeString((*_iter911)); + xfer += oprot->writeString((*_iter913)); } xfer += oprot->writeListEnd(); } @@ -7075,10 +7075,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 _iter912; - for (_iter912 = (*(this->tbl_names)).begin(); _iter912 != (*(this->tbl_names)).end(); ++_iter912) + std::vector<std::string> ::const_iterator _iter914; + for (_iter914 = (*(this->tbl_names)).begin(); _iter914 != (*(this->tbl_names)).end(); ++_iter914) { - xfer += oprot->writeString((*_iter912)); + xfer += oprot->writeString((*_iter914)); } xfer += oprot->writeListEnd(); } @@ -7119,14 +7119,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 _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 _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[_i917].read(iprot); + xfer += this->success[_i919].read(iprot); } xfer += iprot->readListEnd(); } @@ -7181,10 +7181,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 _iter918; - for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) + std::vector<Table> ::const_iterator _iter920; + for (_iter920 = this->success.begin(); _iter920 != this->success.end(); ++_iter920) { - xfer += (*_iter918).write(oprot); + xfer += (*_iter920).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7237,14 +7237,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 _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - (*(this->success)).resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + uint32_t _size921; + ::apache::thrift::protocol::TType _etype924; + xfer += iprot->readListBegin(_etype924, _size921); + (*(this->success)).resize(_size921); + uint32_t _i925; + for (_i925 = 0; _i925 < _size921; ++_i925) { - xfer += (*(this->success))[_i923].read(iprot); + xfer += (*(this->success))[_i925].read(iprot); } xfer += iprot->readListEnd(); } @@ -7430,14 +7430,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 _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 _size926; + ::apache::thrift::protocol::TType _etype929; + xfer += iprot->readListBegin(_etype929, _size926); + this->success.resize(_size926); + uint32_t _i930; + for (_i930 = 0; _i930 < _size926; ++_i930) { - xfer += iprot->readString(this->success[_i928]); + xfer += iprot->readString(this->success[_i930]); } xfer += iprot->readListEnd(); } @@ -7492,10 +7492,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 _iter929; - for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) + std::vector<std::string> ::const_iterator _iter931; + for (_iter931 = this->success.begin(); _iter931 != this->success.end(); ++_iter931) { - xfer += oprot->writeString((*_iter929)); + xfer += oprot->writeString((*_iter931)); } xfer += oprot->writeListEnd(); } @@ -7548,14 +7548,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 _size930; - ::apache::thrift::protocol::TType _etype933; - xfer += iprot->readListBegin(_etype933, _size930); - (*(this->success)).resize(_size930); - uint32_t _i934; - for (_i934 = 0; _i934 < _size930; ++_i934) + uint32_t _size932; + ::apache::thrift::protocol::TType _etype935; + xfer += iprot->readListBegin(_etype935, _size932); + (*(this->success)).resize(_size932); + uint32_t _i936; + for (_i936 = 0; _i936 < _size932; ++_i936) { - xfer += iprot->readString((*(this->success))[_i934]); + xfer += iprot->readString((*(this->success))[_i936]); } xfer += iprot->readListEnd(); } @@ -8889,14 +8889,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size935; - ::apache::thrift::protocol::TType _etype938; - xfer += iprot->readListBegin(_etype938, _size935); - this->new_parts.resize(_size935); - uint32_t _i939; - for (_i939 = 0; _i939 < _size935; ++_i939) + uint32_t _size937; + ::apache::thrift::protocol::TType _etype940; + xfer += iprot->readListBegin(_etype940, _size937); + this->new_parts.resize(_size937); + uint32_t _i941; + for (_i941 = 0; _i941 < _size937; ++_i941) { - xfer += this->new_parts[_i939].read(iprot); + xfer += this->new_parts[_i941].read(iprot); } xfer += iprot->readListEnd(); } @@ -8925,10 +8925,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 _iter940; - for (_iter940 = this->new_parts.begin(); _iter940 != this->new_parts.end(); ++_iter940) + std::vector<Partition> ::const_iterator _iter942; + for (_iter942 = this->new_parts.begin(); _iter942 != this->new_parts.end(); ++_iter942) { - xfer += (*_iter940).write(oprot); + xfer += (*_iter942).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8952,10 +8952,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 _iter941; - for (_iter941 = (*(this->new_parts)).begin(); _iter941 != (*(this->new_parts)).end(); ++_iter941) + std::vector<Partition> ::const_iterator _iter943; + for (_iter943 = (*(this->new_parts)).begin(); _iter943 != (*(this->new_parts)).end(); ++_iter943) { - xfer += (*_iter941).write(oprot); + xfer += (*_iter943).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9164,14 +9164,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 _size942; - ::apache::thrift::protocol::TType _etype945; - xfer += iprot->readListBegin(_etype945, _size942); - this->new_parts.resize(_size942); - uint32_t _i946; - for (_i946 = 0; _i946 < _size942; ++_i946) + uint32_t _size944; + ::apache::thrift::protocol::TType _etype947; + xfer += iprot->readListBegin(_etype947, _size944); + this->new_parts.resize(_size944); + uint32_t _i948; + for (_i948 = 0; _i948 < _size944; ++_i948) { - xfer += this->new_parts[_i946].read(iprot); + xfer += this->new_parts[_i948].read(iprot); } xfer += iprot->readListEnd(); } @@ -9200,10 +9200,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 _iter947; - for (_iter947 = this->new_parts.begin(); _iter947 != this->new_parts.end(); ++_iter947) + std::vector<PartitionSpec> ::const_iterator _iter949; + for (_iter949 = this->new_parts.begin(); _iter949 != this->new_parts.end(); ++_iter949) { - xfer += (*_iter947).write(oprot); + xfer += (*_iter949).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9227,10 +9227,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 _iter948; - for (_iter948 = (*(this->new_parts)).begin(); _iter948 != (*(this->new_parts)).end(); ++_iter948) + std::vector<PartitionSpec> ::const_iterator _iter950; + for (_iter950 = (*(this->new_parts)).begin(); _iter950 != (*(this->new_parts)).end(); ++_iter950) { - xfer += (*_iter948).write(oprot); + xfer += (*_iter950).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9455,14 +9455,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size949; - ::apache::thrift::protocol::TType _etype952; - xfer += iprot->readListBegin(_etype952, _size949); - this->part_vals.resize(_size949); - uint32_t _i953; - for (_i953 = 0; _i953 < _size949; ++_i953) + uint32_t _size951; + ::apache::thrift::protocol::TType _etype954; + xfer += iprot->readListBegin(_etype954, _size951); + this->part_vals.resize(_size951); + uint32_t _i955; + for (_i955 = 0; _i955 < _size951; ++_i955) { - xfer += iprot->readString(this->part_vals[_i953]); + xfer += iprot->readString(this->part_vals[_i955]); } xfer += iprot->readListEnd(); } @@ -9499,10 +9499,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 _iter954; - for (_iter954 = this->part_vals.begin(); _iter954 != this->part_vals.end(); ++_iter954) + std::vector<std::string> ::const_iterator _iter956; + for (_iter956 = this->part_vals.begin(); _iter956 != this->part_vals.end(); ++_iter956) { - xfer += oprot->writeString((*_iter954)); + xfer += oprot->writeString((*_iter956)); } xfer += oprot->writeListEnd(); } @@ -9534,10 +9534,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 _iter955; - for (_iter955 = (*(this->part_vals)).begin(); _iter955 != (*(this->part_vals)).end(); ++_iter955) + std::vector<std::string> ::const_iterator _iter957; + for (_iter957 = (*(this->part_vals)).begin(); _iter957 != (*(this->part_vals)).end(); ++_iter957) { - xfer += oprot->writeString((*_iter955)); + xfer += oprot->writeString((*_iter957)); } xfer += oprot->writeListEnd(); } @@ -10009,14 +10009,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size956; - ::apache::thrift::protocol::TType _etype959; - xfer += iprot->readListBegin(_etype959, _size956); - this->part_vals.resize(_size956); - uint32_t _i960; - for (_i960 = 0; _i960 < _size956; ++_i960) + uint32_t _size958; + ::apache::thrift::protocol::TType _etype961; + xfer += iprot->readListBegin(_etype961, _size958); + this->part_vals.resize(_size958); + uint32_t _i962; + for (_i962 = 0; _i962 < _size958; ++_i962) { - xfer += iprot->readString(this->part_vals[_i960]); + xfer += iprot->readString(this->part_vals[_i962]); } xfer += iprot->readListEnd(); } @@ -10061,10 +10061,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 _iter961; - for (_iter961 = this->part_vals.begin(); _iter961 != this->part_vals.end(); ++_iter961) + std::vector<std::string> ::const_iterator _iter963; + for (_iter963 = this->part_vals.begin(); _iter963 != this->part_vals.end(); ++_iter963) { - xfer += oprot->writeString((*_iter961)); + xfer += oprot->writeString((*_iter963)); } xfer += oprot->writeListEnd(); } @@ -10100,10 +10100,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 _iter962; - for (_iter962 = (*(this->part_vals)).begin(); _iter962 != (*(this->part_vals)).end(); ++_iter962) + std::vector<std::string> ::const_iterator _iter964; + for (_iter964 = (*(this->part_vals)).begin(); _iter964 != (*(this->part_vals)).end(); ++_iter964) { - xfer += oprot->writeString((*_iter962)); + xfer += oprot->writeString((*_iter964)); } xfer += oprot->writeListEnd(); } @@ -10906,14 +10906,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size963; - ::apache::thrift::protocol::TType _etype966; - xfer += iprot->readListBegin(_etype966, _size963); - this->part_vals.resize(_size963); - uint32_t _i967; - for (_i967 = 0; _i967 < _size963; ++_i967) + uint32_t _size965; + ::apache::thrift::protocol::TType _etype968; + xfer += iprot->readListBegin(_etype968, _size965); + this->part_vals.resize(_size965); + uint32_t _i969; + for (_i969 = 0; _i969 < _size965; ++_i969) { - xfer += iprot->readString(this->part_vals[_i967]); + xfer += iprot->readString(this->part_vals[_i969]); } xfer += iprot->readListEnd(); } @@ -10958,10 +10958,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 _iter968; - for (_iter968 = this->part_vals.begin(); _iter968 != this->part_vals.end(); ++_iter968) + std::vector<std::string> ::const_iterator _iter970; + for (_iter970 = this->part_vals.begin(); _iter970 != this->part_vals.end(); ++_iter970) { - xfer += oprot->writeString((*_iter968)); + xfer += oprot->writeString((*_iter970)); } xfer += oprot->writeListEnd(); } @@ -10997,10 +10997,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 _iter969; - for (_iter969 = (*(this->part_vals)).begin(); _iter969 != (*(this->part_vals)).end(); ++_iter969) + std::vector<std::string> ::const_iterator _iter971; + for (_iter971 = (*(this->part_vals)).begin(); _iter971 != (*(this->part_vals)).end(); ++_iter971) { - xfer += oprot->writeString((*_iter969)); + xfer += oprot->writeString((*_iter971)); } xfer += oprot->writeListEnd(); } @@ -11209,14 +11209,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size970; - ::apache::thrift::protocol::TType _etype973; - xfer += iprot->readListBegin(_etype973, _size970); - this->part_vals.resize(_size970); - uint32_t _i974; - for (_i974 = 0; _i974 < _size970; ++_i974) + uint32_t _size972; + ::apache::thrift::protocol::TType _etype975; + xfer += iprot->readListBegin(_etype975, _size972); + this->part_vals.resize(_size972); + uint32_t _i976; + for (_i976 = 0; _i976 < _size972; ++_i976) { - xfer += iprot->readString(this->part_vals[_i974]); + xfer += iprot->readString(this->part_vals[_i976]); } xfer += iprot->readListEnd(); } @@ -11269,10 +11269,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 _iter975; - for (_iter975 = this->part_vals.begin(); _iter975 != this->part_vals.end(); ++_iter975) + std::vector<std::string> ::const_iterator _iter977; + for (_iter977 = this->part_vals.begin(); _iter977 != this->part_vals.end(); ++_iter977) { - xfer += oprot->writeString((*_iter975)); + xfer += oprot->writeString((*_iter977)); } xfer += oprot->writeListEnd(); } @@ -11312,10 +11312,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 _iter976; - for (_iter976 = (*(this->part_vals)).begin(); _iter976 != (*(this->part_vals)).end(); ++_iter976) + std::vector<std::string> ::const_iterator _iter978; + for (_iter978 = (*(this->part_vals)).begin(); _iter978 != (*(this->part_vals)).end(); ++_iter978) { - xfer += oprot->writeString((*_iter976)); + xfer += oprot->writeString((*_iter978)); } xfer += oprot->writeListEnd(); } @@ -12321,14 +12321,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size977; - ::apache::thrift::protocol::TType _etype980; - xfer += iprot->readListBegin(_etype980, _size977); - this->part_vals.resize(_size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + uint32_t _size979; + ::apache::thrift::protocol::TType _etype982; + xfer += iprot->readListBegin(_etype982, _size979); + this->part_vals.resize(_size979); + uint32_t _i983; + for (_i983 = 0; _i983 < _size979; ++_i983) { - xfer += iprot->readString(this->part_vals[_i981]); + xfer += iprot->readString(this->part_vals[_i983]); } xfer += iprot->readListEnd(); } @@ -12365,10 +12365,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 _iter982; - for (_iter982 = this->part_vals.begin(); _iter982 != this->part_vals.end(); ++_iter982) + std::vector<std::string> ::const_iterator _iter984; + for (_iter984 = this->part_vals.begin(); _iter984 != this->part_vals.end(); ++_iter984) { - xfer += oprot->writeString((*_iter982)); + xfer += oprot->writeString((*_iter984)); } xfer += oprot->writeListEnd(); } @@ -12400,10 +12400,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 _iter983; - for (_iter983 = (*(this->part_vals)).begin(); _iter983 != (*(this->part_vals)).end(); ++_iter983) + std::vector<std::string> ::const_iterator _iter985; + for (_iter985 = (*(this->part_vals)).begin(); _iter985 != (*(this->part_vals)).end(); ++_iter985) { - xfer += oprot->writeString((*_iter983)); + xfer += oprot->writeString((*_iter985)); } xfer += oprot->writeListEnd(); } @@ -12592,17 +12592,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size984; - ::apache::thrift::protocol::TType _ktype985; - ::apache::thrift::protocol::TType _vtype986; - xfer += iprot->readMapBegin(_ktype985, _vtype986, _size984); - uint32_t _i988; - for (_i988 = 0; _i988 < _size984; ++_i988) + uint32_t _size986; + ::apache::thrift::protocol::TType _ktype987; + ::apache::thrift::protocol::TType _vtype988; + xfer += iprot->readMapBegin(_ktype987, _vtype988, _size986); + uint32_t _i990; + for (_i990 = 0; _i990 < _size986; ++_i990) { - std::string _key989; - xfer += iprot->readString(_key989); - std::string& _val990 = this->partitionSpecs[_key989]; - xfer += iprot->readString(_val990); + std::string _key991; + xfer += iprot->readString(_key991); + std::string& _val992 = this->partitionSpecs[_key991]; + xfer += iprot->readString(_val992); } xfer += iprot->readMapEnd(); } @@ -12663,11 +12663,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 _iter991; - for (_iter991 = this->partitionSpecs.begin(); _iter991 != this->partitionSpecs.end(); ++_iter991) + std::map<std::string, std::string> ::const_iterator _iter993; + for (_iter993 = this->partitionSpecs.begin(); _iter993 != this->partitionSpecs.end(); ++_iter993) { - xfer += oprot->writeString(_iter991->first); - xfer += oprot->writeString(_iter991->second); + xfer += oprot->writeString(_iter993->first); + xfer += oprot->writeString(_iter993->second); } xfer += oprot->writeMapEnd(); } @@ -12707,11 +12707,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 _iter992; - for (_iter992 = (*(this->partitionSpecs)).begin(); _iter992 != (*(this->partitionSpecs)).end(); ++_iter992) + std::map<std::string, std::string> ::const_iterator _iter994; + for (_iter994 = (*(this->partitionSpecs)).begin(); _iter994 != (*(this->partitionSpecs)).end(); ++_iter994) { - xfer += oprot->writeString(_iter992->first); - xfer += oprot->writeString(_iter992->second); + xfer += oprot->writeString(_iter994->first); + xfer += oprot->writeString(_iter994->second); } xfer += oprot->writeMapEnd(); } @@ -12956,17 +12956,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size993; - ::apache::thrift::protocol::TType _ktype994; - ::apache::thrift::protocol::TType _vtype995; - xfer += iprot->readMapBegin(_ktype994, _vtype995, _size993); - uint32_t _i997; - for (_i997 = 0; _i997 < _size993; ++_i997) + uint32_t _size995; + ::apache::thrift::protocol::TType _ktype996; + ::apache::thrift::protocol::TType _vtype997; + xfer += iprot->readMapBegin(_ktype996, _vtype997, _size995); + uint32_t _i999; + for (_i999 = 0; _i999 < _size995; ++_i999) { - std::string _key998; - xfer += iprot->readString(_key998); - std::string& _val999 = this->partitionSpecs[_key998]; - xfer += iprot->readString(_val999); + std::string _key1000; + xfer += iprot->readString(_key1000); + std::string& _val1001 = this->partitionSpecs[_key1000]; + xfer += iprot->readString(_val1001); } xfer += iprot->readMapEnd(); } @@ -13027,11 +13027,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 _iter1000; - for (_iter1000 = this->partitionSpecs.begin(); _iter1000 != this->partitionSpecs.end(); ++_iter1000) + std::map<std::string, std::string> ::const_iterator _iter1002; + for (_iter1002 = this->partitionSpecs.begin(); _iter1002 != this->partitionSpecs.end(); ++_iter1002) { - xfer += oprot->writeString(_iter1000->first); - xfer += oprot->writeString(_iter1000->second); + xfer += oprot->writeString(_iter1002->first); + xfer += oprot->writeString(_iter1002->second); } xfer += oprot->writeMapEnd(); } @@ -13071,11 +13071,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 _iter1001; - for (_iter1001 = (*(this->partitionSpecs)).begin(); _iter1001 != (*(this->partitionSpecs)).end(); ++_iter1001) + std::map<std::string, std::string> ::const_iterator _iter1003; + for (_iter1003 = (*(this->partitionSpecs)).begin(); _iter1003 != (*(this->partitionSpecs)).end(); ++_iter1003) { - xfer += oprot->writeString(_iter1001->first); - xfer += oprot->writeString(_iter1001->second); + xfer += oprot->writeString(_iter1003->first); + xfer += oprot->writeString(_iter1003->second); } xfer += oprot->writeMapEnd(); } @@ -13132,14 +13132,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - 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) + 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) { - xfer += this->success[_i1006].read(iprot); + xfer += this->success[_i1008].read(iprot); } xfer += iprot->readListEnd(); } @@ -13202,10 +13202,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 _iter1007; - for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007) + std::vector<Partition> ::const_iterator _iter1009; + for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009) { - xfer += (*_iter1007).write(oprot); + xfer += (*_iter1009).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13262,14 +13262,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + 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 += (*(this->success))[_i1012].read(iprot); + xfer += (*(this->success))[_i1014].read(iprot); } xfer += iprot->readListEnd(); } @@ -13368,14 +13368,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 _size1013; - ::apache::thrift::protocol::TType _etype1016; - xfer += iprot->readListBegin(_etype1016, _size1013); - this->part_vals.resize(_size1013); - uint32_t _i1017; - for (_i1017 = 0; _i1017 < _size1013; ++_i1017) + uint32_t _size1015; + ::apache::thrift::protocol::TType _etype1018; + xfer += iprot->readListBegin(_etype1018, _size1015); + this->part_vals.resize(_size1015); + uint32_t _i1019; + for (_i1019 = 0; _i1019 < _size1015; ++_i1019) { - xfer += iprot->readString(this->part_vals[_i1017]); + xfer += iprot->readString(this->part_vals[_i1019]); } xfer += iprot->readListEnd(); } @@ -13396,14 +13396,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 _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - this->group_names.resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1020; + ::apache::thrift::protocol::TType _etype1023; + xfer += iprot->readListBegin(_etype1023, _size1020); + this->group_names.resize(_size1020); + uint32_t _i1024; + for (_i1024 = 0; _i1024 < _size1020; ++_i1024) { - xfer += iprot->readString(this->group_names[_i1022]); + xfer += iprot->readString(this->group_names[_i1024]); } xfer += iprot->readListEnd(); } @@ -13440,10 +13440,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 _iter1023; - for (_iter1023 = this->part_vals.begin(); _iter1023 != this->part_vals.end(); ++_iter1023) + std::vector<std::string> ::const_iterator _iter1025; + for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025) { - xfer += oprot->writeString((*_iter1023)); + xfer += oprot->writeString((*_iter1025)); } xfer += oprot->writeListEnd(); } @@ -13456,10 +13456,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 _iter1024; - for (_iter1024 = this->group_names.begin(); _iter1024 != this->group_names.end(); ++_iter1024) + std::vector<std::string> ::const_iterator _iter1026; + for (_iter1026 = this->group_names.begin(); _iter1026 != this->group_names.end(); ++_iter1026) { - xfer += oprot->writeString((*_iter1024)); + xfer += oprot->writeString((*_iter1026)); } xfer += oprot->writeListEnd(); } @@ -13491,10 +13491,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 _iter1025; - for (_iter1025 = (*(this->part_vals)).begin(); _iter1025 != (*(this->part_vals)).end(); ++_iter1025) + std::vector<std::string> ::const_iterator _iter1027; + for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027) { - xfer += oprot->writeString((*_iter1025)); + xfer += oprot->writeString((*_iter1027)); } xfer += oprot->writeListEnd(); } @@ -13507,10 +13507,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 _iter1026; - for (_iter1026 = (*(this->group_names)).begin(); _iter1026 != (*(this->group_names)).end(); ++_iter1026) + std::vector<std::string> ::const_iterator _iter1028; + for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028) { - xfer += oprot->writeString((*_iter1026)); + xfer += oprot->writeString((*_iter1028)); } xfer += oprot->writeListEnd(); } @@ -14069,14 +14069,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1027; - ::apache::thrift::protocol::TType _etype1030; - xfer += iprot->readListBegin(_etype1030, _size1027); - this->success.resize(_size1027); - uint32_t _i1031; - for (_i1031 = 0; _i1031 < _size1027; ++_i1031) + uint32_t _size1029; + ::apache::thrift::protocol::TType _etype1032; + xfer += iprot->readListBegin(_etype1032, _size1029); + this->success.resize(_size1029); + uint32_t _i1033; + for (_i1033 = 0; _i1033 < _size1029; ++_i1033) { - xfer += this->success[_i1031].read(iprot); + xfer += this->success[_i1033].read(iprot); } xfer += iprot->readListEnd(); } @@ -14123,10 +14123,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 _iter1032; - for (_iter1032 = this->success.begin(); _iter1032 != this->success.end(); ++_iter1032) + std::vector<Partition> ::const_iterator _iter1034; + for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034) { - xfer += (*_iter1032).write(oprot); + xfer += (*_iter1034).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14175,14 +14175,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1033; - ::apache::thrift::protocol::TType _etype1036; - xfer += iprot->readListBegin(_etype1036, _size1033); - (*(this->success)).resize(_size1033); - uint32_t _i1037; - for (_i1037 = 0; _i1037 < _size1033; ++_i1037) + uint32_t _size1035; + ::apache::thrift::protocol::TType _etype1038; + xfer += iprot->readListBegin(_etype1038, _size1035); + (*(this->success)).resize(_size1035); + uint32_t _i1039; + for (_i1039 = 0; _i1039 < _size1035; ++_i1039) { - xfer += (*(this->success))[_i1037].read(iprot); + xfer += (*(this->success))[_i1039].read(iprot); } xfer += iprot->readListEnd(); } @@ -14281,14 +14281,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 _size1038; - ::apache::thrift::protocol::TType _etype1041; - xfer += iprot->readListBegin(_etype1041, _size1038); - this->group_names.resize(_size1038); - uint32_t _i1042; - for (_i1042 = 0; _i1042 < _size1038; ++_i1042) + uint32_t _size1040; + ::apache::thrift::protocol::TType _etype1043; + xfer += iprot->readListBegin(_etype1043, _size1040); + this->group_names.resize(_size1040); + uint32_t _i1044; + for (_i1044 = 0; _i1044 < _size1040; ++_i1044) { - xfer += iprot->readString(this->group_names[_i1042]); + xfer += iprot->readString(this->group_names[_i1044]); } xfer += iprot->readListEnd(); } @@ -14333,10 +14333,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 _iter1043; - for (_iter1043 = this->group_names.begin(); _iter1043 != this->group_names.end(); ++_iter1043) + std::vector<std::string> ::const_iterator _iter1045; + for (_iter1045 = this->group_names.begin(); _iter1045 != this->group_names.end(); ++_iter1045) { - xfer += oprot->writeString((*_iter1043)); + xfer += oprot->writeString((*_iter1045)); } xfer += oprot->writeListEnd(); } @@ -14376,10 +14376,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 _iter1044; - for (_iter1044 = (*(this->group_names)).begin(); _iter1044 != (*(this->group_names)).end(); ++_iter1044) + std::vector<std::string> ::const_iterator _iter1046; + for (_iter1046 = (*(this->group_names)).begin(); _iter1046 != (*(this->group_names)).end(); ++_iter1046) { - xfer += oprot->writeString((*_iter1044)); + xfer += oprot->writeString((*_iter1046)); } xfer += oprot->writeListEnd(); } @@ -14420,14 +14420,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1045; - ::apache::thrift::protocol::TType _etype1048; - xfer += iprot->readListBegin(_etype1048, _size1045); - this->success.resize(_size1045); - uint32_t _i1049; - for (_i1049 = 0; _i1049 < _size1045; ++_i1049) + uint32_t _size1047; + ::apache::thrift::protocol::TType _etype1050; + xfer += iprot->readListBegin(_etype1050, _size1047); + this->success.resize(_size1047); + uint32_t _i1051; + for (_i1051 = 0; _i1051 < _size1047; ++_i1051) { - xfer += this->success[_i1049].read(iprot); + xfer += this->success[_i1051].read(iprot); } xfer += iprot->readListEnd(); } @@ -14474,10 +14474,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 _iter1050; - for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) + std::vector<Partition> ::const_iterator _iter1052; + for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) { - xfer += (*_iter1050).write(oprot); + xfer += (*_iter1052).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14526,14 +14526,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - (*(this->success)).resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1053; + ::apache::thrift::protocol::TType _etype1056; + xfer += iprot->readListBegin(_etype1056, _size1053); + (*(this->success)).resize(_size1053); + uint32_t _i1057; + for (_i1057 = 0; _i1057 < _size1053; ++_i1057) { - xfer += (*(this->success))[_i1055].read(iprot); + xfer += (*(this->success))[_i1057].read(iprot); } xfer += iprot->readListEnd(); } @@ -14711,14 +14711,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->success.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1058; + ::apache::thrift::protocol::TType _etype1061; + xfer += iprot->readListBegin(_etype1061, _size1058); + this->success.resize(_size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - xfer += this->success[_i1060].read(iprot); + xfer += this->success[_i1062].read(iprot); } xfer += iprot->readListEnd(); } @@ -14765,10 +14765,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<PartitionSpec> ::const_iterator _iter1061; - for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061) + std::vector<PartitionSpec> ::const_iterator _iter1063; + for (_iter1063 = this->success.begin(); _iter1063 != this->success.end(); ++_iter1063) { - xfer += (*_iter1061).write(oprot); + xfer += (*_iter1063).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14817,14 +14817,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1062; - ::apache::thrift::protocol::TType _etype1065; - xfer += iprot->readListBegin(_etype1065, _size1062); - (*(this->success)).resize(_size1062); - uint32_t _i1066; - for (_i1066 = 0; _i1066 < _size1062; ++_i1066) + uint32_t _size1064; + ::apache::thrift::protocol::TType _etype1067; + xfer += iprot->readListBegin(_etype1067, _size1064); + (*(this->success)).resize(_size1064); + uint32_t _i1068; + for (_i1068 = 0; _i1068 < _size1064; ++_i1068) { - xfer += (*(this->success))[_i1066].read(iprot); + xfer += (*(this->success))[_i1068].read(iprot); } xfer += iprot->readListEnd(); } @@ -15002,14 +15002,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->success.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1069; + ::apache::thrift::protocol::TType _etype1072; + xfer += iprot->readListBegin(_etype1072, _size1069); + this->success.resize(_size1069); + uint32_t _i1073; + for (_i1073 = 0; _i1073 < _size1069; ++_i1073) { - xfer += iprot->readString(this->success[_i1071]); + xfer += iprot->readString(this->success[_i1073]); }
<TRUNCATED>
