http://git-wip-us.apache.org/repos/asf/hive/blob/b36f6a3a/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 0440df7..618c3ac 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 _size755; - ::apache::thrift::protocol::TType _etype758; - xfer += iprot->readListBegin(_etype758, _size755); - this->success.resize(_size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + 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) { - xfer += iprot->readString(this->success[_i759]); + xfer += iprot->readString(this->success[_i775]); } 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 _iter760; - for (_iter760 = this->success.begin(); _iter760 != this->success.end(); ++_iter760) + std::vector<std::string> ::const_iterator _iter776; + for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776) { - xfer += oprot->writeString((*_iter760)); + xfer += oprot->writeString((*_iter776)); } 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 _size761; - ::apache::thrift::protocol::TType _etype764; - xfer += iprot->readListBegin(_etype764, _size761); - (*(this->success)).resize(_size761); - uint32_t _i765; - for (_i765 = 0; _i765 < _size761; ++_i765) + 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) { - xfer += iprot->readString((*(this->success))[_i765]); + xfer += iprot->readString((*(this->success))[_i781]); } 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 _size766; - ::apache::thrift::protocol::TType _etype769; - xfer += iprot->readListBegin(_etype769, _size766); - this->success.resize(_size766); - uint32_t _i770; - for (_i770 = 0; _i770 < _size766; ++_i770) + 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) { - xfer += iprot->readString(this->success[_i770]); + xfer += iprot->readString(this->success[_i786]); } 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 _iter771; - for (_iter771 = this->success.begin(); _iter771 != this->success.end(); ++_iter771) + std::vector<std::string> ::const_iterator _iter787; + for (_iter787 = this->success.begin(); _iter787 != this->success.end(); ++_iter787) { - xfer += oprot->writeString((*_iter771)); + xfer += oprot->writeString((*_iter787)); } 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 _size772; - ::apache::thrift::protocol::TType _etype775; - xfer += iprot->readListBegin(_etype775, _size772); - (*(this->success)).resize(_size772); - uint32_t _i776; - for (_i776 = 0; _i776 < _size772; ++_i776) + 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) { - xfer += iprot->readString((*(this->success))[_i776]); + xfer += iprot->readString((*(this->success))[_i792]); } 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 _size777; - ::apache::thrift::protocol::TType _ktype778; - ::apache::thrift::protocol::TType _vtype779; - xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777); - uint32_t _i781; - for (_i781 = 0; _i781 < _size777; ++_i781) + uint32_t _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) { - std::string _key782; - xfer += iprot->readString(_key782); - Type& _val783 = this->success[_key782]; - xfer += _val783.read(iprot); + std::string _key798; + xfer += iprot->readString(_key798); + Type& _val799 = this->success[_key798]; + xfer += _val799.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 _iter784; - for (_iter784 = this->success.begin(); _iter784 != this->success.end(); ++_iter784) + std::map<std::string, Type> ::const_iterator _iter800; + for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) { - xfer += oprot->writeString(_iter784->first); - xfer += _iter784->second.write(oprot); + xfer += oprot->writeString(_iter800->first); + xfer += _iter800->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 _size785; - ::apache::thrift::protocol::TType _ktype786; - ::apache::thrift::protocol::TType _vtype787; - xfer += iprot->readMapBegin(_ktype786, _vtype787, _size785); - uint32_t _i789; - for (_i789 = 0; _i789 < _size785; ++_i789) + 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) { - std::string _key790; - xfer += iprot->readString(_key790); - Type& _val791 = (*(this->success))[_key790]; - xfer += _val791.read(iprot); + std::string _key806; + xfer += iprot->readString(_key806); + Type& _val807 = (*(this->success))[_key806]; + xfer += _val807.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 _size792; - ::apache::thrift::protocol::TType _etype795; - xfer += iprot->readListBegin(_etype795, _size792); - this->success.resize(_size792); - uint32_t _i796; - for (_i796 = 0; _i796 < _size792; ++_i796) + 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) { - xfer += this->success[_i796].read(iprot); + xfer += this->success[_i812].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 _iter797; - for (_iter797 = this->success.begin(); _iter797 != this->success.end(); ++_iter797) + std::vector<FieldSchema> ::const_iterator _iter813; + for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) { - xfer += (*_iter797).write(oprot); + xfer += (*_iter813).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 _size798; - ::apache::thrift::protocol::TType _etype801; - xfer += iprot->readListBegin(_etype801, _size798); - (*(this->success)).resize(_size798); - uint32_t _i802; - for (_i802 = 0; _i802 < _size798; ++_i802) + uint32_t _size814; + ::apache::thrift::protocol::TType _etype817; + xfer += iprot->readListBegin(_etype817, _size814); + (*(this->success)).resize(_size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - xfer += (*(this->success))[_i802].read(iprot); + xfer += (*(this->success))[_i818].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 _size803; - ::apache::thrift::protocol::TType _etype806; - xfer += iprot->readListBegin(_etype806, _size803); - this->success.resize(_size803); - uint32_t _i807; - for (_i807 = 0; _i807 < _size803; ++_i807) + 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) { - xfer += this->success[_i807].read(iprot); + xfer += this->success[_i823].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 _iter808; - for (_iter808 = this->success.begin(); _iter808 != this->success.end(); ++_iter808) + std::vector<FieldSchema> ::const_iterator _iter824; + for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) { - xfer += (*_iter808).write(oprot); + xfer += (*_iter824).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 _size809; - ::apache::thrift::protocol::TType _etype812; - xfer += iprot->readListBegin(_etype812, _size809); - (*(this->success)).resize(_size809); - uint32_t _i813; - for (_i813 = 0; _i813 < _size809; ++_i813) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + (*(this->success)).resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += (*(this->success))[_i813].read(iprot); + xfer += (*(this->success))[_i829].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 _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 _size830; + ::apache::thrift::protocol::TType _etype833; + xfer += iprot->readListBegin(_etype833, _size830); + this->success.resize(_size830); + uint32_t _i834; + for (_i834 = 0; _i834 < _size830; ++_i834) { - xfer += this->success[_i818].read(iprot); + xfer += this->success[_i834].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 _iter819; - for (_iter819 = this->success.begin(); _iter819 != this->success.end(); ++_iter819) + std::vector<FieldSchema> ::const_iterator _iter835; + for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835) { - xfer += (*_iter819).write(oprot); + xfer += (*_iter835).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 _size820; - ::apache::thrift::protocol::TType _etype823; - xfer += iprot->readListBegin(_etype823, _size820); - (*(this->success)).resize(_size820); - uint32_t _i824; - for (_i824 = 0; _i824 < _size820; ++_i824) + 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) { - xfer += (*(this->success))[_i824].read(iprot); + xfer += (*(this->success))[_i840].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 _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 _size841; + ::apache::thrift::protocol::TType _etype844; + xfer += iprot->readListBegin(_etype844, _size841); + this->success.resize(_size841); + uint32_t _i845; + for (_i845 = 0; _i845 < _size841; ++_i845) { - xfer += this->success[_i829].read(iprot); + xfer += this->success[_i845].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 _iter830; - for (_iter830 = this->success.begin(); _iter830 != this->success.end(); ++_iter830) + std::vector<FieldSchema> ::const_iterator _iter846; + for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) { - xfer += (*_iter830).write(oprot); + xfer += (*_iter846).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 _size831; - ::apache::thrift::protocol::TType _etype834; - xfer += iprot->readListBegin(_etype834, _size831); - (*(this->success)).resize(_size831); - uint32_t _i835; - for (_i835 = 0; _i835 < _size831; ++_i835) + 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) { - xfer += (*(this->success))[_i835].read(iprot); + xfer += (*(this->success))[_i851].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 _size836; - ::apache::thrift::protocol::TType _etype839; - xfer += iprot->readListBegin(_etype839, _size836); - this->primaryKeys.resize(_size836); - uint32_t _i840; - for (_i840 = 0; _i840 < _size836; ++_i840) + 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) { - xfer += this->primaryKeys[_i840].read(iprot); + xfer += this->primaryKeys[_i856].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 _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - this->foreignKeys.resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + 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) { - xfer += this->foreignKeys[_i845].read(iprot); + xfer += this->foreignKeys[_i861].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 _iter846; - for (_iter846 = this->primaryKeys.begin(); _iter846 != this->primaryKeys.end(); ++_iter846) + std::vector<SQLPrimaryKey> ::const_iterator _iter862; + for (_iter862 = this->primaryKeys.begin(); _iter862 != this->primaryKeys.end(); ++_iter862) { - xfer += (*_iter846).write(oprot); + xfer += (*_iter862).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 _iter847; - for (_iter847 = this->foreignKeys.begin(); _iter847 != this->foreignKeys.end(); ++_iter847) + std::vector<SQLForeignKey> ::const_iterator _iter863; + for (_iter863 = this->foreignKeys.begin(); _iter863 != this->foreignKeys.end(); ++_iter863) { - xfer += (*_iter847).write(oprot); + xfer += (*_iter863).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 _iter848; - for (_iter848 = (*(this->primaryKeys)).begin(); _iter848 != (*(this->primaryKeys)).end(); ++_iter848) + std::vector<SQLPrimaryKey> ::const_iterator _iter864; + for (_iter864 = (*(this->primaryKeys)).begin(); _iter864 != (*(this->primaryKeys)).end(); ++_iter864) { - xfer += (*_iter848).write(oprot); + xfer += (*_iter864).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 _iter849; - for (_iter849 = (*(this->foreignKeys)).begin(); _iter849 != (*(this->foreignKeys)).end(); ++_iter849) + std::vector<SQLForeignKey> ::const_iterator _iter865; + for (_iter865 = (*(this->foreignKeys)).begin(); _iter865 != (*(this->foreignKeys)).end(); ++_iter865) { - xfer += (*_iter849).write(oprot); + xfer += (*_iter865).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5023,11 +5023,11 @@ uint32_t ThriftHiveMetastore_drop_constraint_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { +ThriftHiveMetastore_add_primary_key_args::~ThriftHiveMetastore_add_primary_key_args() throw() { } -uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_primary_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5049,25 +5049,170 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->dbname); - this->__isset.dbname = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_primary_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_pargs::~ThriftHiveMetastore_add_primary_key_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_add_primary_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_result::~ThriftHiveMetastore_add_primary_key_result() throw() { +} + + +uint32_t ThriftHiveMetastore_add_primary_key_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; case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->name); - this->__isset.name = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; } else { xfer += iprot->skip(ftype); } break; - case 3: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->deleteData); - this->__isset.deleteData = true; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_primary_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_primary_key_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_primary_key_presult::~ThriftHiveMetastore_add_primary_key_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_add_primary_key_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; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; } else { xfer += iprot->skip(ftype); } @@ -5084,21 +5229,59 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + +ThriftHiveMetastore_add_foreign_key_args::~ThriftHiveMetastore_add_foreign_key_args() throw() { +} + + +uint32_t ThriftHiveMetastore_add_foreign_key_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; - apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->dbname); - xfer += oprot->writeFieldEnd(); + xfer += iprot->readStructBegin(fname); - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->name); - xfer += oprot->writeFieldEnd(); + using ::apache::thrift::protocol::TProtocolException; - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool(this->deleteData); + + 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->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_foreign_key_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5107,25 +5290,17 @@ uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { +ThriftHiveMetastore_add_foreign_key_pargs::~ThriftHiveMetastore_add_foreign_key_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_foreign_key_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_pargs"); - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->dbname))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->name))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5134,11 +5309,250 @@ uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { +ThriftHiveMetastore_add_foreign_key_result::~ThriftHiveMetastore_add_foreign_key_result() throw() { } -uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_foreign_key_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; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_foreign_key_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_foreign_key_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_foreign_key_presult::~ThriftHiveMetastore_add_foreign_key_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_add_foreign_key_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; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_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->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); + + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5641,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 _size850; - ::apache::thrift::protocol::TType _etype853; - xfer += iprot->readListBegin(_etype853, _size850); - this->success.resize(_size850); - uint32_t _i854; - for (_i854 = 0; _i854 < _size850; ++_i854) + uint32_t _size866; + ::apache::thrift::protocol::TType _etype869; + xfer += iprot->readListBegin(_etype869, _size866); + this->success.resize(_size866); + uint32_t _i870; + for (_i870 = 0; _i870 < _size866; ++_i870) { - xfer += iprot->readString(this->success[_i854]); + xfer += iprot->readString(this->success[_i870]); } xfer += iprot->readListEnd(); } @@ -5687,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 _iter855; - for (_iter855 = this->success.begin(); _iter855 != this->success.end(); ++_iter855) + std::vector<std::string> ::const_iterator _iter871; + for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871) { - xfer += oprot->writeString((*_iter855)); + xfer += oprot->writeString((*_iter871)); } xfer += oprot->writeListEnd(); } @@ -5735,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 _size856; - ::apache::thrift::protocol::TType _etype859; - xfer += iprot->readListBegin(_etype859, _size856); - (*(this->success)).resize(_size856); - uint32_t _i860; - for (_i860 = 0; _i860 < _size856; ++_i860) + 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) { - xfer += iprot->readString((*(this->success))[_i860]); + xfer += iprot->readString((*(this->success))[_i876]); } xfer += iprot->readListEnd(); } @@ -5817,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 _size861; - ::apache::thrift::protocol::TType _etype864; - xfer += iprot->readListBegin(_etype864, _size861); - this->tbl_types.resize(_size861); - uint32_t _i865; - for (_i865 = 0; _i865 < _size861; ++_i865) + 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) { - xfer += iprot->readString(this->tbl_types[_i865]); + xfer += iprot->readString(this->tbl_types[_i881]); } xfer += iprot->readListEnd(); } @@ -5861,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 _iter866; - for (_iter866 = this->tbl_types.begin(); _iter866 != this->tbl_types.end(); ++_iter866) + std::vector<std::string> ::const_iterator _iter882; + for (_iter882 = this->tbl_types.begin(); _iter882 != this->tbl_types.end(); ++_iter882) { - xfer += oprot->writeString((*_iter866)); + xfer += oprot->writeString((*_iter882)); } xfer += oprot->writeListEnd(); } @@ -5896,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 _iter867; - for (_iter867 = (*(this->tbl_types)).begin(); _iter867 != (*(this->tbl_types)).end(); ++_iter867) + std::vector<std::string> ::const_iterator _iter883; + for (_iter883 = (*(this->tbl_types)).begin(); _iter883 != (*(this->tbl_types)).end(); ++_iter883) { - xfer += oprot->writeString((*_iter867)); + xfer += oprot->writeString((*_iter883)); } xfer += oprot->writeListEnd(); } @@ -5940,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 _size868; - ::apache::thrift::protocol::TType _etype871; - xfer += iprot->readListBegin(_etype871, _size868); - this->success.resize(_size868); - uint32_t _i872; - for (_i872 = 0; _i872 < _size868; ++_i872) + 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) { - xfer += this->success[_i872].read(iprot); + xfer += this->success[_i888].read(iprot); } xfer += iprot->readListEnd(); } @@ -5986,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 _iter873; - for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) + std::vector<TableMeta> ::const_iterator _iter889; + for (_iter889 = this->success.begin(); _iter889 != this->success.end(); ++_iter889) { - xfer += (*_iter873).write(oprot); + xfer += (*_iter889).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6034,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 _size874; - ::apache::thrift::protocol::TType _etype877; - xfer += iprot->readListBegin(_etype877, _size874); - (*(this->success)).resize(_size874); - uint32_t _i878; - for (_i878 = 0; _i878 < _size874; ++_i878) + 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) { - xfer += (*(this->success))[_i878].read(iprot); + xfer += (*(this->success))[_i894].read(iprot); } xfer += iprot->readListEnd(); } @@ -6179,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 _size879; - ::apache::thrift::protocol::TType _etype882; - xfer += iprot->readListBegin(_etype882, _size879); - this->success.resize(_size879); - uint32_t _i883; - for (_i883 = 0; _i883 < _size879; ++_i883) + uint32_t _size895; + ::apache::thrift::protocol::TType _etype898; + xfer += iprot->readListBegin(_etype898, _size895); + this->success.resize(_size895); + uint32_t _i899; + for (_i899 = 0; _i899 < _size895; ++_i899) { - xfer += iprot->readString(this->success[_i883]); + xfer += iprot->readString(this->success[_i899]); } xfer += iprot->readListEnd(); } @@ -6225,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 _iter884; - for (_iter884 = this->success.begin(); _iter884 != this->success.end(); ++_iter884) + std::vector<std::string> ::const_iterator _iter900; + for (_iter900 = this->success.begin(); _iter900 != this->success.end(); ++_iter900) { - xfer += oprot->writeString((*_iter884)); + xfer += oprot->writeString((*_iter900)); } xfer += oprot->writeListEnd(); } @@ -6273,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 _size885; - ::apache::thrift::protocol::TType _etype888; - xfer += iprot->readListBegin(_etype888, _size885); - (*(this->success)).resize(_size885); - uint32_t _i889; - for (_i889 = 0; _i889 < _size885; ++_i889) + uint32_t _size901; + ::apache::thrift::protocol::TType _etype904; + xfer += iprot->readListBegin(_etype904, _size901); + (*(this->success)).resize(_size901); + uint32_t _i905; + for (_i905 = 0; _i905 < _size901; ++_i905) { - xfer += iprot->readString((*(this->success))[_i889]); + xfer += iprot->readString((*(this->success))[_i905]); } xfer += iprot->readListEnd(); } @@ -6590,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 _size890; - ::apache::thrift::protocol::TType _etype893; - xfer += iprot->readListBegin(_etype893, _size890); - this->tbl_names.resize(_size890); - uint32_t _i894; - for (_i894 = 0; _i894 < _size890; ++_i894) + 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) { - xfer += iprot->readString(this->tbl_names[_i894]); + xfer += iprot->readString(this->tbl_names[_i910]); } xfer += iprot->readListEnd(); } @@ -6630,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 _iter895; - for (_iter895 = this->tbl_names.begin(); _iter895 != this->tbl_names.end(); ++_iter895) + std::vector<std::string> ::const_iterator _iter911; + for (_iter911 = this->tbl_names.begin(); _iter911 != this->tbl_names.end(); ++_iter911) { - xfer += oprot->writeString((*_iter895)); + xfer += oprot->writeString((*_iter911)); } xfer += oprot->writeListEnd(); } @@ -6661,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 _iter896; - for (_iter896 = (*(this->tbl_names)).begin(); _iter896 != (*(this->tbl_names)).end(); ++_iter896) + std::vector<std::string> ::const_iterator _iter912; + for (_iter912 = (*(this->tbl_names)).begin(); _iter912 != (*(this->tbl_names)).end(); ++_iter912) { - xfer += oprot->writeString((*_iter896)); + xfer += oprot->writeString((*_iter912)); } xfer += oprot->writeListEnd(); } @@ -6705,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 _size897; - ::apache::thrift::protocol::TType _etype900; - xfer += iprot->readListBegin(_etype900, _size897); - this->success.resize(_size897); - uint32_t _i901; - for (_i901 = 0; _i901 < _size897; ++_i901) + uint32_t _size913; + ::apache::thrift::protocol::TType _etype916; + xfer += iprot->readListBegin(_etype916, _size913); + this->success.resize(_size913); + uint32_t _i917; + for (_i917 = 0; _i917 < _size913; ++_i917) { - xfer += this->success[_i901].read(iprot); + xfer += this->success[_i917].read(iprot); } xfer += iprot->readListEnd(); } @@ -6767,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 _iter902; - for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902) + std::vector<Table> ::const_iterator _iter918; + for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918) { - xfer += (*_iter902).write(oprot); + xfer += (*_iter918).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6823,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 _size903; - ::apache::thrift::protocol::TType _etype906; - xfer += iprot->readListBegin(_etype906, _size903); - (*(this->success)).resize(_size903); - uint32_t _i907; - for (_i907 = 0; _i907 < _size903; ++_i907) + uint32_t _size919; + ::apache::thrift::protocol::TType _etype922; + xfer += iprot->readListBegin(_etype922, _size919); + (*(this->success)).resize(_size919); + uint32_t _i923; + for (_i923 = 0; _i923 < _size919; ++_i923) { - xfer += (*(this->success))[_i907].read(iprot); + xfer += (*(this->success))[_i923].read(iprot); } xfer += iprot->readListEnd(); } @@ -7016,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 _size908; - ::apache::thrift::protocol::TType _etype911; - xfer += iprot->readListBegin(_etype911, _size908); - this->success.resize(_size908); - uint32_t _i912; - for (_i912 = 0; _i912 < _size908; ++_i912) + uint32_t _size924; + ::apache::thrift::protocol::TType _etype927; + xfer += iprot->readListBegin(_etype927, _size924); + this->success.resize(_size924); + uint32_t _i928; + for (_i928 = 0; _i928 < _size924; ++_i928) { - xfer += iprot->readString(this->success[_i912]); + xfer += iprot->readString(this->success[_i928]); } xfer += iprot->readListEnd(); } @@ -7078,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 _iter913; - for (_iter913 = this->success.begin(); _iter913 != this->success.end(); ++_iter913) + std::vector<std::string> ::const_iterator _iter929; + for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929) { - xfer += oprot->writeString((*_iter913)); + xfer += oprot->writeString((*_iter929)); } xfer += oprot->writeListEnd(); } @@ -7134,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 _size914; - ::apache::thrift::protocol::TType _etype917; - xfer += iprot->readListBegin(_etype917, _size914); - (*(this->success)).resize(_size914); - uint32_t _i918; - for (_i918 = 0; _i918 < _size914; ++_i918) + 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) { - xfer += iprot->readString((*(this->success))[_i918]); + xfer += iprot->readString((*(this->success))[_i934]); } xfer += iprot->readListEnd(); } @@ -8475,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 _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - this->new_parts.resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) + 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) { - xfer += this->new_parts[_i923].read(iprot); + xfer += this->new_parts[_i939].read(iprot); } xfer += iprot->readListEnd(); } @@ -8511,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 _iter924; - for (_iter924 = this->new_parts.begin(); _iter924 != this->new_parts.end(); ++_iter924) + std::vector<Partition> ::const_iterator _iter940; + for (_iter940 = this->new_parts.begin(); _iter940 != this->new_parts.end(); ++_iter940) { - xfer += (*_iter924).write(oprot); + xfer += (*_iter940).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8538,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 _iter925; - for (_iter925 = (*(this->new_parts)).begin(); _iter925 != (*(this->new_parts)).end(); ++_iter925) + std::vector<Partition> ::const_iterator _iter941; + for (_iter941 = (*(this->new_parts)).begin(); _iter941 != (*(this->new_parts)).end(); ++_iter941) { - xfer += (*_iter925).write(oprot); + xfer += (*_iter941).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8750,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 _size926; - ::apache::thrift::protocol::TType _etype929; - xfer += iprot->readListBegin(_etype929, _size926); - this->new_parts.resize(_size926); - uint32_t _i930; - for (_i930 = 0; _i930 < _size926; ++_i930) + 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) { - xfer += this->new_parts[_i930].read(iprot); + xfer += this->new_parts[_i946].read(iprot); } xfer += iprot->readListEnd(); } @@ -8786,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 _iter931; - for (_iter931 = this->new_parts.begin(); _iter931 != this->new_parts.end(); ++_iter931) + std::vector<PartitionSpec> ::const_iterator _iter947; + for (_iter947 = this->new_parts.begin(); _iter947 != this->new_parts.end(); ++_iter947) { - xfer += (*_iter931).write(oprot); + xfer += (*_iter947).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8813,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 _iter932; - for (_iter932 = (*(this->new_parts)).begin(); _iter932 != (*(this->new_parts)).end(); ++_iter932) + std::vector<PartitionSpec> ::const_iterator _iter948; + for (_iter948 = (*(this->new_parts)).begin(); _iter948 != (*(this->new_parts)).end(); ++_iter948) { - xfer += (*_iter932).write(oprot); + xfer += (*_iter948).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9041,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 _size933; - ::apache::thrift::protocol::TType _etype936; - xfer += iprot->readListBegin(_etype936, _size933); - this->part_vals.resize(_size933); - uint32_t _i937; - for (_i937 = 0; _i937 < _size933; ++_i937) + 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) { - xfer += iprot->readString(this->part_vals[_i937]); + xfer += iprot->readString(this->part_vals[_i953]); } xfer += iprot->readListEnd(); } @@ -9085,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 _iter938; - for (_iter938 = this->part_vals.begin(); _iter938 != this->part_vals.end(); ++_iter938) + std::vector<std::string> ::const_iterator _iter954; + for (_iter954 = this->part_vals.begin(); _iter954 != this->part_vals.end(); ++_iter954) { - xfer += oprot->writeString((*_iter938)); + xfer += oprot->writeString((*_iter954)); } xfer += oprot->writeListEnd(); } @@ -9120,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 _iter939; - for (_iter939 = (*(this->part_vals)).begin(); _iter939 != (*(this->part_vals)).end(); ++_iter939) + std::vector<std::string> ::const_iterator _iter955; + for (_iter955 = (*(this->part_vals)).begin(); _iter955 != (*(this->part_vals)).end(); ++_iter955) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter955)); } xfer += oprot->writeListEnd(); } @@ -9595,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 _size940; - ::apache::thrift::protocol::TType _etype943; - xfer += iprot->readListBegin(_etype943, _size940); - this->part_vals.resize(_size940); - uint32_t _i944; - for (_i944 = 0; _i944 < _size940; ++_i944) + 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) { - xfer += iprot->readString(this->part_vals[_i944]); + xfer += iprot->readString(this->part_vals[_i960]); } xfer += iprot->readListEnd(); } @@ -9647,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 _iter945; - for (_iter945 = this->part_vals.begin(); _iter945 != this->part_vals.end(); ++_iter945) + std::vector<std::string> ::const_iterator _iter961; + for (_iter961 = this->part_vals.begin(); _iter961 != this->part_vals.end(); ++_iter961) { - xfer += oprot->writeString((*_iter945)); + xfer += oprot->writeString((*_iter961)); } xfer += oprot->writeListEnd(); } @@ -9686,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 _iter946; - for (_iter946 = (*(this->part_vals)).begin(); _iter946 != (*(this->part_vals)).end(); ++_iter946) + std::vector<std::string> ::const_iterator _iter962; + for (_iter962 = (*(this->part_vals)).begin(); _iter962 != (*(this->part_vals)).end(); ++_iter962) { - xfer += oprot->writeString((*_iter946)); + xfer += oprot->writeString((*_iter962)); } xfer += oprot->writeListEnd(); } @@ -10492,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 _size947; - ::apache::thrift::protocol::TType _etype950; - xfer += iprot->readListBegin(_etype950, _size947); - this->part_vals.resize(_size947); - uint32_t _i951; - for (_i951 = 0; _i951 < _size947; ++_i951) + 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) { - xfer += iprot->readString(this->part_vals[_i951]); + xfer += iprot->readString(this->part_vals[_i967]); } xfer += iprot->readListEnd(); } @@ -10544,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 _iter952; - for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952) + std::vector<std::string> ::const_iterator _iter968; + for (_iter968 = this->part_vals.begin(); _iter968 != this->part_vals.end(); ++_iter968) { - xfer += oprot->writeString((*_iter952)); + xfer += oprot->writeString((*_iter968)); } xfer += oprot->writeListEnd(); } @@ -10583,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 _iter953; - for (_iter953 = (*(this->part_vals)).begin(); _iter953 != (*(this->part_vals)).end(); ++_iter953) + std::vector<std::string> ::const_iterator _iter969; + for (_iter969 = (*(this->part_vals)).begin(); _iter969 != (*(this->part_vals)).end(); ++_iter969) { - xfer += oprot->writeString((*_iter953)); + xfer += oprot->writeString((*_iter969)); } xfer += oprot->writeListEnd(); } @@ -10795,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 _size954; - ::apache::thrift::protocol::TType _etype957; - xfer += iprot->readListBegin(_etype957, _size954); - this->part_vals.resize(_size954); - uint32_t _i958; - for (_i958 = 0; _i958 < _size954; ++_i958) + 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) { - xfer += iprot->readString(this->part_vals[_i958]); + xfer += iprot->readString(this->part_vals[_i974]); } xfer += iprot->readListEnd(); } @@ -10855,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 _iter959; - for (_iter959 = this->part_vals.begin(); _iter959 != this->part_vals.end(); ++_iter959) + std::vector<std::string> ::const_iterator _iter975; + for (_iter975 = this->part_vals.begin(); _iter975 != this->part_vals.end(); ++_iter975) { - xfer += oprot->writeString((*_iter959)); + xfer += oprot->writeString((*_iter975)); } xfer += oprot->writeListEnd(); } @@ -10898,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 _iter960; - for (_iter960 = (*(this->part_vals)).begin(); _iter960 != (*(this->part_vals)).end(); ++_iter960) + std::vector<std::string> ::const_iterator _iter976; + for (_iter976 = (*(this->part_vals)).begin(); _iter976 != (*(this->part_vals)).end(); ++_iter976) { - xfer += oprot->writeString((*_iter960)); + xfer += oprot->writeString((*_iter976)); } xfer += oprot->writeListEnd(); } @@ -11907,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 _size961; - ::apache::thrift::protocol::TType _etype964; - xfer += iprot->readListBegin(_etype964, _size961); - this->part_vals.resize(_size961); - uint32_t _i965; - for (_i965 = 0; _i965 < _size961; ++_i965) + 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) { - xfer += iprot->readString(this->part_vals[_i965]); + xfer += iprot->readString(this->part_vals[_i981]); } xfer += iprot->readListEnd(); } @@ -11951,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 _iter966; - for (_iter966 = this->part_vals.begin(); _iter966 != this->part_vals.end(); ++_iter966) + std::vector<std::string> ::const_iterator _iter982; + for (_iter982 = this->part_vals.begin(); _iter982 != this->part_vals.end(); ++_iter982) { - xfer += oprot->writeString((*_iter966)); + xfer += oprot->writeString((*_iter982)); } xfer += oprot->writeListEnd(); } @@ -11986,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 _iter967; - for (_iter967 = (*(this->part_vals)).begin(); _iter967 != (*(this->part_vals)).end(); ++_iter967) + std::vector<std::string> ::const_iterator _iter983; + for (_iter983 = (*(this->part_vals)).begin(); _iter983 != (*(this->part_vals)).end(); ++_iter983) { - xfer += oprot->writeString((*_iter967)); + xfer += oprot->writeString((*_iter983)); } xfer += oprot->writeListEnd(); } @@ -12178,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 _size968; - ::apache::thrift::protocol::TType _ktype969; - ::apache::thrift::protocol::TType _vtype970; - xfer += iprot->readMapBegin(_ktype969, _vtype970, _size968); - uint32_t _i972; - for (_i972 = 0; _i972 < _size968; ++_i972) + 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) { - std::string _key973; - xfer += iprot->readString(_key973); - std::string& _val974 = this->partitionSpecs[_key973]; - xfer += iprot->readString(_val974); + std::string _key989; + xfer += iprot->readString(_key989); + std::string& _val990 = this->partitionSpecs[_key989]; + xfer += iprot->readString(_val990); } xfer += iprot->readMapEnd(); } @@ -12249,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 _iter975; - for (_iter975 = this->partitionSpecs.begin(); _iter975 != this->partitionSpecs.end(); ++_iter975) + std::map<std::string, std::string> ::const_iterator _iter991; + for (_iter991 = this->partitionSpecs.begin(); _iter991 != this->partitionSpecs.end(); ++_iter991) { - xfer += oprot->writeString(_iter975->first); - xfer += oprot->writeString(_iter975->second); + xfer += oprot->writeString(_iter991->first); + xfer += oprot->writeString(_iter991->second); } xfer += oprot->writeMapEnd(); } @@ -12293,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 _iter976; - for (_iter976 = (*(this->partitionSpecs)).begin(); _iter976 != (*(this->partitionSpecs)).end(); ++_iter976) + std::map<std::string, std::string> ::const_iterator _iter992; + for (_iter992 = (*(this->partitionSpecs)).begin(); _iter992 != (*(this->partitionSpecs)).end(); ++_iter992) { - xfer += oprot->writeString(_iter976->first); - xfer += oprot->writeString(_iter976->second); + xfer += oprot->writeString(_iter992->first); + xfer += oprot->writeString(_iter992->second); } xfer += oprot->writeMapEnd(); } @@ -12542,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 _size977; - ::apache::thrift::protocol::TType _ktype978; - ::apache::thrift::protocol::TType _vtype979; - xfer += iprot->readMapBegin(_ktype978, _vtype979, _size977); - uint32_t _i981; - for (_i981 = 0; _i981 < _size977; ++_i981) + 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) { - std::string _key982; - xfer += iprot->readString(_key982); - std::string& _val983 = this->partitionSpecs[_key982]; - xfer += iprot->readString(_val983); + std::string _key998; + xfer += iprot->readString(_key998); + std::string& _val999 = this->partitionSpecs[_key998]; + xfer += iprot->readString(_val999); } xfer += iprot->readMapEnd(); } @@ -12613,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 _iter984; - for (_iter984 = this->partitionSpecs.begin(); _iter984 != this->partitionSpecs.end(); ++_iter984) + std::map<std::string, std::string> ::const_iterator _iter1000; + for (_iter1000 = this->partitionSpecs.begin(); _iter1000 != this->partitionSpecs.end(); ++_iter1000) { - xfer += oprot->writeString(_iter984->first); - xfer += oprot->writeString(_iter984->second); + xfer += oprot->writeString(_iter1000->first); + xfer += oprot->writeString(_iter1000->second); } xfer += oprot->writeMapEnd(); } @@ -12657,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 _iter985; - for (_iter985 = (*(this->partitionSpecs)).begin(); _iter985 != (*(this->partitionSpecs)).end(); ++_iter985) + std::map<std::string, std::string> ::const_iterator _iter1001; + for (_iter1001 = (*(this->partitionSpecs)).begin(); _iter1001 != (*(this->partitionSpecs)).end(); ++_iter1001) { - xfer += oprot->writeString(_iter985->first); - xfer += oprot->writeString(_iter985->second); + xfer += oprot->writeString(_iter1001->first); + xfer += oprot->writeString(_iter1001->second); } xfer += oprot->writeMapEnd(); } @@ -12718,14 +13132,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size986; - ::apache::thrift::protocol::TType _etype989; - xfer += iprot->readListBegin(_etype989, _size986); - this->success.resize(_size986); - uint32_t _i990; - for (_i990 = 0; _i990 < _size986; ++_i990) + uint32_t _size1002; + ::apache::thrift::protocol::TType _etype1005; + xfer += iprot->readListBegin(_etype1005, _size1002); + this->success.resize(_size1002); + uint32_t _i1006; + for (_i1006 = 0; _i1006 < _size1002; ++_i1006) { - xfer += this->success[_i990].read(iprot); + xfer += this->success[_i1006].read(iprot); } xfer += iprot->readListEnd(); } @@ -12788,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 _iter991; - for (_iter991 = this->success.begin(); _iter991 != this->success.end(); ++_iter991) + std::vector<Partition> ::const_iterator _iter1007; + for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007) { - xfer += (*_iter991).write(oprot); + xfer += (*_iter1007).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12848,14 +13262,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size992; - ::apache::thrift::protocol::TType _etype995; - xfer += iprot->readListBegin(_etype995, _size992); - (*(this->success)).resize(_size992); - uint32_t _i996; - for (_i996 = 0; _i996 < _size992; ++_i996) + uint32_t _size1008; + ::apache::thrift::protocol::TType _etype1011; + xfer += iprot->readListBegin(_etype1011, _size1008); + (*(this->success)).resize(_size1008); + uint32_t _i1012; + for (_i1012 = 0; _i1012 < _size1008; ++_i1012) { - xfer += (*(this->success))[_i996].read(iprot); + xfer += (*(this->success))[_i1012].read(iprot); } xfer += iprot->readListEnd(); } @@ -12954,14 +13368,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype ==
<TRUNCATED>
