diff --git a/metastore/if/hive_metastore.thrift b/metastore/if/hive_metastore.thrift index acebf7a..f80ad84 100755 --- a/metastore/if/hive_metastore.thrift +++ b/metastore/if/hive_metastore.thrift @@ -449,7 +449,13 @@ struct AggrStats { } struct SetPartitionsStatsRequest { -1: required list colStats +1: required list colStats, +2: optional i32 numBitVector +} + +struct SetColumnStatsRequest { +1: required ColumnStatistics colStats, +2: optional i32 numBitVector } // schema of the table/query results etc. @@ -1244,11 +1250,17 @@ service ThriftHiveMetastore extends fb303.FacebookService // exists for one or more columns, the existing statistics will be overwritten. The update APIs // validate that the dbName, tableName, partName, colName[] passed in as part of the ColumnStatistics // struct are valid, throws InvalidInputException/NoSuchObjectException if found to be invalid + // these functions will be substituted by the following functions which allow merging stats. bool update_table_column_statistics(1:ColumnStatistics stats_obj) throws (1:NoSuchObjectException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) bool update_partition_column_statistics(1:ColumnStatistics stats_obj) throws (1:NoSuchObjectException o1, 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) + // updated APIs persist the column statistics object(s) that are passed in. If statistics already + // exists for one or more columns, the existing statistics will be overwritten/merged. + bool renew_column_statistics(1:SetColumnStatsRequest request) throws (1:NoSuchObjectException o1, + 2:InvalidObjectException o2, 3:MetaException o3, 4:InvalidInputException o4) + // get APIs return the column statistics corresponding to db_name, tbl_name, [part_name], col_name if // such statistics exists. If the required statistics doesn't exist, get APIs throw NoSuchObjectException // For instance, if get_table_column_statistics is called on a partitioned table for which only diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 690c895..a33e699 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 _size749; - ::apache::thrift::protocol::TType _etype752; - xfer += iprot->readListBegin(_etype752, _size749); - this->success.resize(_size749); - uint32_t _i753; - for (_i753 = 0; _i753 < _size749; ++_i753) + uint32_t _size751; + ::apache::thrift::protocol::TType _etype754; + xfer += iprot->readListBegin(_etype754, _size751); + this->success.resize(_size751); + uint32_t _i755; + for (_i755 = 0; _i755 < _size751; ++_i755) { - xfer += iprot->readString(this->success[_i753]); + xfer += iprot->readString(this->success[_i755]); } 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(this->success.size())); - std::vector ::const_iterator _iter754; - for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) + std::vector ::const_iterator _iter756; + for (_iter756 = this->success.begin(); _iter756 != this->success.end(); ++_iter756) { - xfer += oprot->writeString((*_iter754)); + xfer += oprot->writeString((*_iter756)); } 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 _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 _size757; + ::apache::thrift::protocol::TType _etype760; + xfer += iprot->readListBegin(_etype760, _size757); + (*(this->success)).resize(_size757); + uint32_t _i761; + for (_i761 = 0; _i761 < _size757; ++_i761) { - xfer += iprot->readString((*(this->success))[_i759]); + xfer += iprot->readString((*(this->success))[_i761]); } 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 _size760; - ::apache::thrift::protocol::TType _etype763; - xfer += iprot->readListBegin(_etype763, _size760); - this->success.resize(_size760); - uint32_t _i764; - for (_i764 = 0; _i764 < _size760; ++_i764) + uint32_t _size762; + ::apache::thrift::protocol::TType _etype765; + xfer += iprot->readListBegin(_etype765, _size762); + this->success.resize(_size762); + uint32_t _i766; + for (_i766 = 0; _i766 < _size762; ++_i766) { - xfer += iprot->readString(this->success[_i764]); + xfer += iprot->readString(this->success[_i766]); } 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(this->success.size())); - std::vector ::const_iterator _iter765; - for (_iter765 = this->success.begin(); _iter765 != this->success.end(); ++_iter765) + std::vector ::const_iterator _iter767; + for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) { - xfer += oprot->writeString((*_iter765)); + xfer += oprot->writeString((*_iter767)); } 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 _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 _size768; + ::apache::thrift::protocol::TType _etype771; + xfer += iprot->readListBegin(_etype771, _size768); + (*(this->success)).resize(_size768); + uint32_t _i772; + for (_i772 = 0; _i772 < _size768; ++_i772) { - xfer += iprot->readString((*(this->success))[_i770]); + xfer += iprot->readString((*(this->success))[_i772]); } 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 _size771; - ::apache::thrift::protocol::TType _ktype772; - ::apache::thrift::protocol::TType _vtype773; - xfer += iprot->readMapBegin(_ktype772, _vtype773, _size771); - uint32_t _i775; - for (_i775 = 0; _i775 < _size771; ++_i775) + uint32_t _size773; + ::apache::thrift::protocol::TType _ktype774; + ::apache::thrift::protocol::TType _vtype775; + xfer += iprot->readMapBegin(_ktype774, _vtype775, _size773); + uint32_t _i777; + for (_i777 = 0; _i777 < _size773; ++_i777) { - std::string _key776; - xfer += iprot->readString(_key776); - Type& _val777 = this->success[_key776]; - xfer += _val777.read(iprot); + std::string _key778; + xfer += iprot->readString(_key778); + Type& _val779 = this->success[_key778]; + xfer += _val779.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(this->success.size())); - std::map ::const_iterator _iter778; - for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) + std::map ::const_iterator _iter780; + for (_iter780 = this->success.begin(); _iter780 != this->success.end(); ++_iter780) { - xfer += oprot->writeString(_iter778->first); - xfer += _iter778->second.write(oprot); + xfer += oprot->writeString(_iter780->first); + xfer += _iter780->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 _size779; - ::apache::thrift::protocol::TType _ktype780; - ::apache::thrift::protocol::TType _vtype781; - xfer += iprot->readMapBegin(_ktype780, _vtype781, _size779); - uint32_t _i783; - for (_i783 = 0; _i783 < _size779; ++_i783) + uint32_t _size781; + ::apache::thrift::protocol::TType _ktype782; + ::apache::thrift::protocol::TType _vtype783; + xfer += iprot->readMapBegin(_ktype782, _vtype783, _size781); + uint32_t _i785; + for (_i785 = 0; _i785 < _size781; ++_i785) { - std::string _key784; - xfer += iprot->readString(_key784); - Type& _val785 = (*(this->success))[_key784]; - xfer += _val785.read(iprot); + std::string _key786; + xfer += iprot->readString(_key786); + Type& _val787 = (*(this->success))[_key786]; + xfer += _val787.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 _size786; - ::apache::thrift::protocol::TType _etype789; - xfer += iprot->readListBegin(_etype789, _size786); - this->success.resize(_size786); - uint32_t _i790; - for (_i790 = 0; _i790 < _size786; ++_i790) + 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 += this->success[_i790].read(iprot); + xfer += this->success[_i792].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(this->success.size())); - std::vector ::const_iterator _iter791; - for (_iter791 = this->success.begin(); _iter791 != this->success.end(); ++_iter791) + std::vector ::const_iterator _iter793; + for (_iter793 = this->success.begin(); _iter793 != this->success.end(); ++_iter793) { - xfer += (*_iter791).write(oprot); + xfer += (*_iter793).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 _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 _size794; + ::apache::thrift::protocol::TType _etype797; + xfer += iprot->readListBegin(_etype797, _size794); + (*(this->success)).resize(_size794); + uint32_t _i798; + for (_i798 = 0; _i798 < _size794; ++_i798) { - xfer += (*(this->success))[_i796].read(iprot); + xfer += (*(this->success))[_i798].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 _size797; - ::apache::thrift::protocol::TType _etype800; - xfer += iprot->readListBegin(_etype800, _size797); - this->success.resize(_size797); - uint32_t _i801; - for (_i801 = 0; _i801 < _size797; ++_i801) + uint32_t _size799; + ::apache::thrift::protocol::TType _etype802; + xfer += iprot->readListBegin(_etype802, _size799); + this->success.resize(_size799); + uint32_t _i803; + for (_i803 = 0; _i803 < _size799; ++_i803) { - xfer += this->success[_i801].read(iprot); + xfer += this->success[_i803].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(this->success.size())); - std::vector ::const_iterator _iter802; - for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) + std::vector ::const_iterator _iter804; + for (_iter804 = this->success.begin(); _iter804 != this->success.end(); ++_iter804) { - xfer += (*_iter802).write(oprot); + xfer += (*_iter804).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 _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 _size805; + ::apache::thrift::protocol::TType _etype808; + xfer += iprot->readListBegin(_etype808, _size805); + (*(this->success)).resize(_size805); + uint32_t _i809; + for (_i809 = 0; _i809 < _size805; ++_i809) { - xfer += (*(this->success))[_i807].read(iprot); + xfer += (*(this->success))[_i809].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 _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(); } @@ -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(this->success.size())); - std::vector ::const_iterator _iter813; - for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) + std::vector ::const_iterator _iter815; + for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815) { - xfer += (*_iter813).write(oprot); + xfer += (*_iter815).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 _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(); } @@ -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 _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(); } @@ -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(this->success.size())); - std::vector ::const_iterator _iter824; - for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) + std::vector ::const_iterator _iter826; + for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826) { - xfer += (*_iter824).write(oprot); + xfer += (*_iter826).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 _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(); } @@ -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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - this->primaryKeys.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->primaryKeys.resize(_size832); + uint32_t _i836; + for (_i836 = 0; _i836 < _size832; ++_i836) { - xfer += this->primaryKeys[_i834].read(iprot); + xfer += this->primaryKeys[_i836].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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - this->foreignKeys.resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + uint32_t _size837; + ::apache::thrift::protocol::TType _etype840; + xfer += iprot->readListBegin(_etype840, _size837); + this->foreignKeys.resize(_size837); + uint32_t _i841; + for (_i841 = 0; _i841 < _size837; ++_i841) { - xfer += this->foreignKeys[_i839].read(iprot); + xfer += this->foreignKeys[_i841].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(this->primaryKeys.size())); - std::vector ::const_iterator _iter840; - for (_iter840 = this->primaryKeys.begin(); _iter840 != this->primaryKeys.end(); ++_iter840) + std::vector ::const_iterator _iter842; + for (_iter842 = this->primaryKeys.begin(); _iter842 != this->primaryKeys.end(); ++_iter842) { - xfer += (*_iter840).write(oprot); + xfer += (*_iter842).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(this->foreignKeys.size())); - std::vector ::const_iterator _iter841; - for (_iter841 = this->foreignKeys.begin(); _iter841 != this->foreignKeys.end(); ++_iter841) + std::vector ::const_iterator _iter843; + for (_iter843 = this->foreignKeys.begin(); _iter843 != this->foreignKeys.end(); ++_iter843) { - xfer += (*_iter841).write(oprot); + xfer += (*_iter843).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((*(this->primaryKeys)).size())); - std::vector ::const_iterator _iter842; - for (_iter842 = (*(this->primaryKeys)).begin(); _iter842 != (*(this->primaryKeys)).end(); ++_iter842) + std::vector ::const_iterator _iter844; + for (_iter844 = (*(this->primaryKeys)).begin(); _iter844 != (*(this->primaryKeys)).end(); ++_iter844) { - xfer += (*_iter842).write(oprot); + xfer += (*_iter844).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((*(this->foreignKeys)).size())); - std::vector ::const_iterator _iter843; - for (_iter843 = (*(this->foreignKeys)).begin(); _iter843 != (*(this->foreignKeys)).end(); ++_iter843) + std::vector ::const_iterator _iter845; + for (_iter845 = (*(this->foreignKeys)).begin(); _iter845 != (*(this->foreignKeys)).end(); ++_iter845) { - xfer += (*_iter843).write(oprot); + xfer += (*_iter845).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5434,14 +5434,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size844; - ::apache::thrift::protocol::TType _etype847; - xfer += iprot->readListBegin(_etype847, _size844); - this->success.resize(_size844); - uint32_t _i848; - for (_i848 = 0; _i848 < _size844; ++_i848) + uint32_t _size846; + ::apache::thrift::protocol::TType _etype849; + xfer += iprot->readListBegin(_etype849, _size846); + this->success.resize(_size846); + uint32_t _i850; + for (_i850 = 0; _i850 < _size846; ++_i850) { - xfer += iprot->readString(this->success[_i848]); + xfer += iprot->readString(this->success[_i850]); } xfer += iprot->readListEnd(); } @@ -5480,10 +5480,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(this->success.size())); - std::vector ::const_iterator _iter849; - for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) + std::vector ::const_iterator _iter851; + for (_iter851 = this->success.begin(); _iter851 != this->success.end(); ++_iter851) { - xfer += oprot->writeString((*_iter849)); + xfer += oprot->writeString((*_iter851)); } xfer += oprot->writeListEnd(); } @@ -5528,14 +5528,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::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 _size852; + ::apache::thrift::protocol::TType _etype855; + xfer += iprot->readListBegin(_etype855, _size852); + (*(this->success)).resize(_size852); + uint32_t _i856; + for (_i856 = 0; _i856 < _size852; ++_i856) { - xfer += iprot->readString((*(this->success))[_i854]); + xfer += iprot->readString((*(this->success))[_i856]); } xfer += iprot->readListEnd(); } @@ -5610,14 +5610,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 _size855; - ::apache::thrift::protocol::TType _etype858; - xfer += iprot->readListBegin(_etype858, _size855); - this->tbl_types.resize(_size855); - uint32_t _i859; - for (_i859 = 0; _i859 < _size855; ++_i859) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + this->tbl_types.resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += iprot->readString(this->tbl_types[_i859]); + xfer += iprot->readString(this->tbl_types[_i861]); } xfer += iprot->readListEnd(); } @@ -5654,10 +5654,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(this->tbl_types.size())); - std::vector ::const_iterator _iter860; - for (_iter860 = this->tbl_types.begin(); _iter860 != this->tbl_types.end(); ++_iter860) + std::vector ::const_iterator _iter862; + for (_iter862 = this->tbl_types.begin(); _iter862 != this->tbl_types.end(); ++_iter862) { - xfer += oprot->writeString((*_iter860)); + xfer += oprot->writeString((*_iter862)); } xfer += oprot->writeListEnd(); } @@ -5689,10 +5689,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((*(this->tbl_types)).size())); - std::vector ::const_iterator _iter861; - for (_iter861 = (*(this->tbl_types)).begin(); _iter861 != (*(this->tbl_types)).end(); ++_iter861) + std::vector ::const_iterator _iter863; + for (_iter863 = (*(this->tbl_types)).begin(); _iter863 != (*(this->tbl_types)).end(); ++_iter863) { - xfer += oprot->writeString((*_iter861)); + xfer += oprot->writeString((*_iter863)); } xfer += oprot->writeListEnd(); } @@ -5733,14 +5733,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size862; - ::apache::thrift::protocol::TType _etype865; - xfer += iprot->readListBegin(_etype865, _size862); - this->success.resize(_size862); - uint32_t _i866; - for (_i866 = 0; _i866 < _size862; ++_i866) + uint32_t _size864; + ::apache::thrift::protocol::TType _etype867; + xfer += iprot->readListBegin(_etype867, _size864); + this->success.resize(_size864); + uint32_t _i868; + for (_i868 = 0; _i868 < _size864; ++_i868) { - xfer += this->success[_i866].read(iprot); + xfer += this->success[_i868].read(iprot); } xfer += iprot->readListEnd(); } @@ -5779,10 +5779,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(this->success.size())); - std::vector ::const_iterator _iter867; - for (_iter867 = this->success.begin(); _iter867 != this->success.end(); ++_iter867) + std::vector ::const_iterator _iter869; + for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) { - xfer += (*_iter867).write(oprot); + xfer += (*_iter869).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5827,14 +5827,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot 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 _size870; + ::apache::thrift::protocol::TType _etype873; + xfer += iprot->readListBegin(_etype873, _size870); + (*(this->success)).resize(_size870); + uint32_t _i874; + for (_i874 = 0; _i874 < _size870; ++_i874) { - xfer += (*(this->success))[_i872].read(iprot); + xfer += (*(this->success))[_i874].read(iprot); } xfer += iprot->readListEnd(); } @@ -5972,14 +5972,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size873; - ::apache::thrift::protocol::TType _etype876; - xfer += iprot->readListBegin(_etype876, _size873); - this->success.resize(_size873); - uint32_t _i877; - for (_i877 = 0; _i877 < _size873; ++_i877) + uint32_t _size875; + ::apache::thrift::protocol::TType _etype878; + xfer += iprot->readListBegin(_etype878, _size875); + this->success.resize(_size875); + uint32_t _i879; + for (_i879 = 0; _i879 < _size875; ++_i879) { - xfer += iprot->readString(this->success[_i877]); + xfer += iprot->readString(this->success[_i879]); } xfer += iprot->readListEnd(); } @@ -6018,10 +6018,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(this->success.size())); - std::vector ::const_iterator _iter878; - for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) + std::vector ::const_iterator _iter880; + for (_iter880 = this->success.begin(); _iter880 != this->success.end(); ++_iter880) { - xfer += oprot->writeString((*_iter878)); + xfer += oprot->writeString((*_iter880)); } xfer += oprot->writeListEnd(); } @@ -6066,14 +6066,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot 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 _size881; + ::apache::thrift::protocol::TType _etype884; + xfer += iprot->readListBegin(_etype884, _size881); + (*(this->success)).resize(_size881); + uint32_t _i885; + for (_i885 = 0; _i885 < _size881; ++_i885) { - xfer += iprot->readString((*(this->success))[_i883]); + xfer += iprot->readString((*(this->success))[_i885]); } xfer += iprot->readListEnd(); } @@ -6383,14 +6383,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 _size884; - ::apache::thrift::protocol::TType _etype887; - xfer += iprot->readListBegin(_etype887, _size884); - this->tbl_names.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->tbl_names.resize(_size886); + uint32_t _i890; + for (_i890 = 0; _i890 < _size886; ++_i890) { - xfer += iprot->readString(this->tbl_names[_i888]); + xfer += iprot->readString(this->tbl_names[_i890]); } xfer += iprot->readListEnd(); } @@ -6423,10 +6423,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(this->tbl_names.size())); - std::vector ::const_iterator _iter889; - for (_iter889 = this->tbl_names.begin(); _iter889 != this->tbl_names.end(); ++_iter889) + std::vector ::const_iterator _iter891; + for (_iter891 = this->tbl_names.begin(); _iter891 != this->tbl_names.end(); ++_iter891) { - xfer += oprot->writeString((*_iter889)); + xfer += oprot->writeString((*_iter891)); } xfer += oprot->writeListEnd(); } @@ -6454,10 +6454,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((*(this->tbl_names)).size())); - std::vector ::const_iterator _iter890; - for (_iter890 = (*(this->tbl_names)).begin(); _iter890 != (*(this->tbl_names)).end(); ++_iter890) + std::vector ::const_iterator _iter892; + for (_iter892 = (*(this->tbl_names)).begin(); _iter892 != (*(this->tbl_names)).end(); ++_iter892) { - xfer += oprot->writeString((*_iter890)); + xfer += oprot->writeString((*_iter892)); } xfer += oprot->writeListEnd(); } @@ -6498,14 +6498,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 _size891; - ::apache::thrift::protocol::TType _etype894; - xfer += iprot->readListBegin(_etype894, _size891); - this->success.resize(_size891); - uint32_t _i895; - for (_i895 = 0; _i895 < _size891; ++_i895) + uint32_t _size893; + ::apache::thrift::protocol::TType _etype896; + xfer += iprot->readListBegin(_etype896, _size893); + this->success.resize(_size893); + uint32_t _i897; + for (_i897 = 0; _i897 < _size893; ++_i897) { - xfer += this->success[_i895].read(iprot); + xfer += this->success[_i897].read(iprot); } xfer += iprot->readListEnd(); } @@ -6560,10 +6560,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(this->success.size())); - std::vector ::const_iterator _iter896; - for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) + std::vector
::const_iterator _iter898; + for (_iter898 = this->success.begin(); _iter898 != this->success.end(); ++_iter898) { - xfer += (*_iter896).write(oprot); + xfer += (*_iter898).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6616,14 +6616,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 _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 _size899; + ::apache::thrift::protocol::TType _etype902; + xfer += iprot->readListBegin(_etype902, _size899); + (*(this->success)).resize(_size899); + uint32_t _i903; + for (_i903 = 0; _i903 < _size899; ++_i903) { - xfer += (*(this->success))[_i901].read(iprot); + xfer += (*(this->success))[_i903].read(iprot); } xfer += iprot->readListEnd(); } @@ -6809,14 +6809,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 _size902; - ::apache::thrift::protocol::TType _etype905; - xfer += iprot->readListBegin(_etype905, _size902); - this->success.resize(_size902); - uint32_t _i906; - for (_i906 = 0; _i906 < _size902; ++_i906) + uint32_t _size904; + ::apache::thrift::protocol::TType _etype907; + xfer += iprot->readListBegin(_etype907, _size904); + this->success.resize(_size904); + uint32_t _i908; + for (_i908 = 0; _i908 < _size904; ++_i908) { - xfer += iprot->readString(this->success[_i906]); + xfer += iprot->readString(this->success[_i908]); } xfer += iprot->readListEnd(); } @@ -6871,10 +6871,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(this->success.size())); - std::vector ::const_iterator _iter907; - for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907) + std::vector ::const_iterator _iter909; + for (_iter909 = this->success.begin(); _iter909 != this->success.end(); ++_iter909) { - xfer += oprot->writeString((*_iter907)); + xfer += oprot->writeString((*_iter909)); } xfer += oprot->writeListEnd(); } @@ -6927,14 +6927,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 _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 _size910; + ::apache::thrift::protocol::TType _etype913; + xfer += iprot->readListBegin(_etype913, _size910); + (*(this->success)).resize(_size910); + uint32_t _i914; + for (_i914 = 0; _i914 < _size910; ++_i914) { - xfer += iprot->readString((*(this->success))[_i912]); + xfer += iprot->readString((*(this->success))[_i914]); } xfer += iprot->readListEnd(); } @@ -8268,14 +8268,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size913; - ::apache::thrift::protocol::TType _etype916; - xfer += iprot->readListBegin(_etype916, _size913); - this->new_parts.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->new_parts.resize(_size915); + uint32_t _i919; + for (_i919 = 0; _i919 < _size915; ++_i919) { - xfer += this->new_parts[_i917].read(iprot); + xfer += this->new_parts[_i919].read(iprot); } xfer += iprot->readListEnd(); } @@ -8304,10 +8304,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(this->new_parts.size())); - std::vector ::const_iterator _iter918; - for (_iter918 = this->new_parts.begin(); _iter918 != this->new_parts.end(); ++_iter918) + std::vector ::const_iterator _iter920; + for (_iter920 = this->new_parts.begin(); _iter920 != this->new_parts.end(); ++_iter920) { - xfer += (*_iter918).write(oprot); + xfer += (*_iter920).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8331,10 +8331,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((*(this->new_parts)).size())); - std::vector ::const_iterator _iter919; - for (_iter919 = (*(this->new_parts)).begin(); _iter919 != (*(this->new_parts)).end(); ++_iter919) + std::vector ::const_iterator _iter921; + for (_iter921 = (*(this->new_parts)).begin(); _iter921 != (*(this->new_parts)).end(); ++_iter921) { - xfer += (*_iter919).write(oprot); + xfer += (*_iter921).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8543,14 +8543,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 _size920; - ::apache::thrift::protocol::TType _etype923; - xfer += iprot->readListBegin(_etype923, _size920); - this->new_parts.resize(_size920); - uint32_t _i924; - for (_i924 = 0; _i924 < _size920; ++_i924) + uint32_t _size922; + ::apache::thrift::protocol::TType _etype925; + xfer += iprot->readListBegin(_etype925, _size922); + this->new_parts.resize(_size922); + uint32_t _i926; + for (_i926 = 0; _i926 < _size922; ++_i926) { - xfer += this->new_parts[_i924].read(iprot); + xfer += this->new_parts[_i926].read(iprot); } xfer += iprot->readListEnd(); } @@ -8579,10 +8579,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(this->new_parts.size())); - std::vector ::const_iterator _iter925; - for (_iter925 = this->new_parts.begin(); _iter925 != this->new_parts.end(); ++_iter925) + std::vector ::const_iterator _iter927; + for (_iter927 = this->new_parts.begin(); _iter927 != this->new_parts.end(); ++_iter927) { - xfer += (*_iter925).write(oprot); + xfer += (*_iter927).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8606,10 +8606,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((*(this->new_parts)).size())); - std::vector ::const_iterator _iter926; - for (_iter926 = (*(this->new_parts)).begin(); _iter926 != (*(this->new_parts)).end(); ++_iter926) + std::vector ::const_iterator _iter928; + for (_iter928 = (*(this->new_parts)).begin(); _iter928 != (*(this->new_parts)).end(); ++_iter928) { - xfer += (*_iter926).write(oprot); + xfer += (*_iter928).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8834,14 +8834,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size927; - ::apache::thrift::protocol::TType _etype930; - xfer += iprot->readListBegin(_etype930, _size927); - this->part_vals.resize(_size927); - uint32_t _i931; - for (_i931 = 0; _i931 < _size927; ++_i931) + uint32_t _size929; + ::apache::thrift::protocol::TType _etype932; + xfer += iprot->readListBegin(_etype932, _size929); + this->part_vals.resize(_size929); + uint32_t _i933; + for (_i933 = 0; _i933 < _size929; ++_i933) { - xfer += iprot->readString(this->part_vals[_i931]); + xfer += iprot->readString(this->part_vals[_i933]); } xfer += iprot->readListEnd(); } @@ -8878,10 +8878,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(this->part_vals.size())); - std::vector ::const_iterator _iter932; - for (_iter932 = this->part_vals.begin(); _iter932 != this->part_vals.end(); ++_iter932) + std::vector ::const_iterator _iter934; + for (_iter934 = this->part_vals.begin(); _iter934 != this->part_vals.end(); ++_iter934) { - xfer += oprot->writeString((*_iter932)); + xfer += oprot->writeString((*_iter934)); } xfer += oprot->writeListEnd(); } @@ -8913,10 +8913,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter933; - for (_iter933 = (*(this->part_vals)).begin(); _iter933 != (*(this->part_vals)).end(); ++_iter933) + std::vector ::const_iterator _iter935; + for (_iter935 = (*(this->part_vals)).begin(); _iter935 != (*(this->part_vals)).end(); ++_iter935) { - xfer += oprot->writeString((*_iter933)); + xfer += oprot->writeString((*_iter935)); } xfer += oprot->writeListEnd(); } @@ -9388,14 +9388,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size934; - ::apache::thrift::protocol::TType _etype937; - xfer += iprot->readListBegin(_etype937, _size934); - this->part_vals.resize(_size934); - uint32_t _i938; - for (_i938 = 0; _i938 < _size934; ++_i938) + uint32_t _size936; + ::apache::thrift::protocol::TType _etype939; + xfer += iprot->readListBegin(_etype939, _size936); + this->part_vals.resize(_size936); + uint32_t _i940; + for (_i940 = 0; _i940 < _size936; ++_i940) { - xfer += iprot->readString(this->part_vals[_i938]); + xfer += iprot->readString(this->part_vals[_i940]); } xfer += iprot->readListEnd(); } @@ -9440,10 +9440,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(this->part_vals.size())); - std::vector ::const_iterator _iter939; - for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) + std::vector ::const_iterator _iter941; + for (_iter941 = this->part_vals.begin(); _iter941 != this->part_vals.end(); ++_iter941) { - xfer += oprot->writeString((*_iter939)); + xfer += oprot->writeString((*_iter941)); } xfer += oprot->writeListEnd(); } @@ -9479,10 +9479,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter940; - for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) + std::vector ::const_iterator _iter942; + for (_iter942 = (*(this->part_vals)).begin(); _iter942 != (*(this->part_vals)).end(); ++_iter942) { - xfer += oprot->writeString((*_iter940)); + xfer += oprot->writeString((*_iter942)); } xfer += oprot->writeListEnd(); } @@ -10285,14 +10285,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->part_vals.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) + uint32_t _size943; + ::apache::thrift::protocol::TType _etype946; + xfer += iprot->readListBegin(_etype946, _size943); + this->part_vals.resize(_size943); + uint32_t _i947; + for (_i947 = 0; _i947 < _size943; ++_i947) { - xfer += iprot->readString(this->part_vals[_i945]); + xfer += iprot->readString(this->part_vals[_i947]); } xfer += iprot->readListEnd(); } @@ -10337,10 +10337,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(this->part_vals.size())); - std::vector ::const_iterator _iter946; - for (_iter946 = this->part_vals.begin(); _iter946 != this->part_vals.end(); ++_iter946) + std::vector ::const_iterator _iter948; + for (_iter948 = this->part_vals.begin(); _iter948 != this->part_vals.end(); ++_iter948) { - xfer += oprot->writeString((*_iter946)); + xfer += oprot->writeString((*_iter948)); } xfer += oprot->writeListEnd(); } @@ -10376,10 +10376,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter947; - for (_iter947 = (*(this->part_vals)).begin(); _iter947 != (*(this->part_vals)).end(); ++_iter947) + std::vector ::const_iterator _iter949; + for (_iter949 = (*(this->part_vals)).begin(); _iter949 != (*(this->part_vals)).end(); ++_iter949) { - xfer += oprot->writeString((*_iter947)); + xfer += oprot->writeString((*_iter949)); } xfer += oprot->writeListEnd(); } @@ -10588,14 +10588,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - this->part_vals.resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size950; + ::apache::thrift::protocol::TType _etype953; + xfer += iprot->readListBegin(_etype953, _size950); + this->part_vals.resize(_size950); + uint32_t _i954; + for (_i954 = 0; _i954 < _size950; ++_i954) { - xfer += iprot->readString(this->part_vals[_i952]); + xfer += iprot->readString(this->part_vals[_i954]); } xfer += iprot->readListEnd(); } @@ -10648,10 +10648,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(this->part_vals.size())); - std::vector ::const_iterator _iter953; - for (_iter953 = this->part_vals.begin(); _iter953 != this->part_vals.end(); ++_iter953) + std::vector ::const_iterator _iter955; + for (_iter955 = this->part_vals.begin(); _iter955 != this->part_vals.end(); ++_iter955) { - xfer += oprot->writeString((*_iter953)); + xfer += oprot->writeString((*_iter955)); } xfer += oprot->writeListEnd(); } @@ -10691,10 +10691,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter954; - for (_iter954 = (*(this->part_vals)).begin(); _iter954 != (*(this->part_vals)).end(); ++_iter954) + std::vector ::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(); } @@ -11700,14 +11700,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size955; - ::apache::thrift::protocol::TType _etype958; - xfer += iprot->readListBegin(_etype958, _size955); - this->part_vals.resize(_size955); - uint32_t _i959; - for (_i959 = 0; _i959 < _size955; ++_i959) + uint32_t _size957; + ::apache::thrift::protocol::TType _etype960; + xfer += iprot->readListBegin(_etype960, _size957); + this->part_vals.resize(_size957); + uint32_t _i961; + for (_i961 = 0; _i961 < _size957; ++_i961) { - xfer += iprot->readString(this->part_vals[_i959]); + xfer += iprot->readString(this->part_vals[_i961]); } xfer += iprot->readListEnd(); } @@ -11744,10 +11744,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(this->part_vals.size())); - std::vector ::const_iterator _iter960; - for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) + std::vector ::const_iterator _iter962; + for (_iter962 = this->part_vals.begin(); _iter962 != this->part_vals.end(); ++_iter962) { - xfer += oprot->writeString((*_iter960)); + xfer += oprot->writeString((*_iter962)); } xfer += oprot->writeListEnd(); } @@ -11779,10 +11779,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter961; - for (_iter961 = (*(this->part_vals)).begin(); _iter961 != (*(this->part_vals)).end(); ++_iter961) + std::vector ::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(); } @@ -11971,17 +11971,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size962; - ::apache::thrift::protocol::TType _ktype963; - ::apache::thrift::protocol::TType _vtype964; - xfer += iprot->readMapBegin(_ktype963, _vtype964, _size962); - uint32_t _i966; - for (_i966 = 0; _i966 < _size962; ++_i966) + uint32_t _size964; + ::apache::thrift::protocol::TType _ktype965; + ::apache::thrift::protocol::TType _vtype966; + xfer += iprot->readMapBegin(_ktype965, _vtype966, _size964); + uint32_t _i968; + for (_i968 = 0; _i968 < _size964; ++_i968) { - std::string _key967; - xfer += iprot->readString(_key967); - std::string& _val968 = this->partitionSpecs[_key967]; - xfer += iprot->readString(_val968); + std::string _key969; + xfer += iprot->readString(_key969); + std::string& _val970 = this->partitionSpecs[_key969]; + xfer += iprot->readString(_val970); } xfer += iprot->readMapEnd(); } @@ -12042,11 +12042,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(this->partitionSpecs.size())); - std::map ::const_iterator _iter969; - for (_iter969 = this->partitionSpecs.begin(); _iter969 != this->partitionSpecs.end(); ++_iter969) + std::map ::const_iterator _iter971; + for (_iter971 = this->partitionSpecs.begin(); _iter971 != this->partitionSpecs.end(); ++_iter971) { - xfer += oprot->writeString(_iter969->first); - xfer += oprot->writeString(_iter969->second); + xfer += oprot->writeString(_iter971->first); + xfer += oprot->writeString(_iter971->second); } xfer += oprot->writeMapEnd(); } @@ -12086,11 +12086,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((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter970; - for (_iter970 = (*(this->partitionSpecs)).begin(); _iter970 != (*(this->partitionSpecs)).end(); ++_iter970) + std::map ::const_iterator _iter972; + for (_iter972 = (*(this->partitionSpecs)).begin(); _iter972 != (*(this->partitionSpecs)).end(); ++_iter972) { - xfer += oprot->writeString(_iter970->first); - xfer += oprot->writeString(_iter970->second); + xfer += oprot->writeString(_iter972->first); + xfer += oprot->writeString(_iter972->second); } xfer += oprot->writeMapEnd(); } @@ -12335,17 +12335,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size971; - ::apache::thrift::protocol::TType _ktype972; - ::apache::thrift::protocol::TType _vtype973; - xfer += iprot->readMapBegin(_ktype972, _vtype973, _size971); - uint32_t _i975; - for (_i975 = 0; _i975 < _size971; ++_i975) + uint32_t _size973; + ::apache::thrift::protocol::TType _ktype974; + ::apache::thrift::protocol::TType _vtype975; + xfer += iprot->readMapBegin(_ktype974, _vtype975, _size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - std::string _key976; - xfer += iprot->readString(_key976); - std::string& _val977 = this->partitionSpecs[_key976]; - xfer += iprot->readString(_val977); + std::string _key978; + xfer += iprot->readString(_key978); + std::string& _val979 = this->partitionSpecs[_key978]; + xfer += iprot->readString(_val979); } xfer += iprot->readMapEnd(); } @@ -12406,11 +12406,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(this->partitionSpecs.size())); - std::map ::const_iterator _iter978; - for (_iter978 = this->partitionSpecs.begin(); _iter978 != this->partitionSpecs.end(); ++_iter978) + std::map ::const_iterator _iter980; + for (_iter980 = this->partitionSpecs.begin(); _iter980 != this->partitionSpecs.end(); ++_iter980) { - xfer += oprot->writeString(_iter978->first); - xfer += oprot->writeString(_iter978->second); + xfer += oprot->writeString(_iter980->first); + xfer += oprot->writeString(_iter980->second); } xfer += oprot->writeMapEnd(); } @@ -12450,11 +12450,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((*(this->partitionSpecs)).size())); - std::map ::const_iterator _iter979; - for (_iter979 = (*(this->partitionSpecs)).begin(); _iter979 != (*(this->partitionSpecs)).end(); ++_iter979) + std::map ::const_iterator _iter981; + for (_iter981 = (*(this->partitionSpecs)).begin(); _iter981 != (*(this->partitionSpecs)).end(); ++_iter981) { - xfer += oprot->writeString(_iter979->first); - xfer += oprot->writeString(_iter979->second); + xfer += oprot->writeString(_iter981->first); + xfer += oprot->writeString(_iter981->second); } xfer += oprot->writeMapEnd(); } @@ -12511,14 +12511,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size980; - ::apache::thrift::protocol::TType _etype983; - xfer += iprot->readListBegin(_etype983, _size980); - this->success.resize(_size980); - uint32_t _i984; - for (_i984 = 0; _i984 < _size980; ++_i984) + uint32_t _size982; + ::apache::thrift::protocol::TType _etype985; + xfer += iprot->readListBegin(_etype985, _size982); + this->success.resize(_size982); + uint32_t _i986; + for (_i986 = 0; _i986 < _size982; ++_i986) { - xfer += this->success[_i984].read(iprot); + xfer += this->success[_i986].read(iprot); } xfer += iprot->readListEnd(); } @@ -12581,10 +12581,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(this->success.size())); - std::vector ::const_iterator _iter985; - for (_iter985 = this->success.begin(); _iter985 != this->success.end(); ++_iter985) + std::vector ::const_iterator _iter987; + for (_iter987 = this->success.begin(); _iter987 != this->success.end(); ++_iter987) { - xfer += (*_iter985).write(oprot); + xfer += (*_iter987).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12641,14 +12641,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::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 _size988; + ::apache::thrift::protocol::TType _etype991; + xfer += iprot->readListBegin(_etype991, _size988); + (*(this->success)).resize(_size988); + uint32_t _i992; + for (_i992 = 0; _i992 < _size988; ++_i992) { - xfer += (*(this->success))[_i990].read(iprot); + xfer += (*(this->success))[_i992].read(iprot); } xfer += iprot->readListEnd(); } @@ -12747,14 +12747,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 _size991; - ::apache::thrift::protocol::TType _etype994; - xfer += iprot->readListBegin(_etype994, _size991); - this->part_vals.resize(_size991); - uint32_t _i995; - for (_i995 = 0; _i995 < _size991; ++_i995) + uint32_t _size993; + ::apache::thrift::protocol::TType _etype996; + xfer += iprot->readListBegin(_etype996, _size993); + this->part_vals.resize(_size993); + uint32_t _i997; + for (_i997 = 0; _i997 < _size993; ++_i997) { - xfer += iprot->readString(this->part_vals[_i995]); + xfer += iprot->readString(this->part_vals[_i997]); } xfer += iprot->readListEnd(); } @@ -12775,14 +12775,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 _size996; - ::apache::thrift::protocol::TType _etype999; - xfer += iprot->readListBegin(_etype999, _size996); - this->group_names.resize(_size996); - uint32_t _i1000; - for (_i1000 = 0; _i1000 < _size996; ++_i1000) + uint32_t _size998; + ::apache::thrift::protocol::TType _etype1001; + xfer += iprot->readListBegin(_etype1001, _size998); + this->group_names.resize(_size998); + uint32_t _i1002; + for (_i1002 = 0; _i1002 < _size998; ++_i1002) { - xfer += iprot->readString(this->group_names[_i1000]); + xfer += iprot->readString(this->group_names[_i1002]); } xfer += iprot->readListEnd(); } @@ -12819,10 +12819,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(this->part_vals.size())); - std::vector ::const_iterator _iter1001; - for (_iter1001 = this->part_vals.begin(); _iter1001 != this->part_vals.end(); ++_iter1001) + std::vector ::const_iterator _iter1003; + for (_iter1003 = this->part_vals.begin(); _iter1003 != this->part_vals.end(); ++_iter1003) { - xfer += oprot->writeString((*_iter1001)); + xfer += oprot->writeString((*_iter1003)); } xfer += oprot->writeListEnd(); } @@ -12835,10 +12835,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(this->group_names.size())); - std::vector ::const_iterator _iter1002; - for (_iter1002 = this->group_names.begin(); _iter1002 != this->group_names.end(); ++_iter1002) + std::vector ::const_iterator _iter1004; + for (_iter1004 = this->group_names.begin(); _iter1004 != this->group_names.end(); ++_iter1004) { - xfer += oprot->writeString((*_iter1002)); + xfer += oprot->writeString((*_iter1004)); } xfer += oprot->writeListEnd(); } @@ -12870,10 +12870,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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1003; - for (_iter1003 = (*(this->part_vals)).begin(); _iter1003 != (*(this->part_vals)).end(); ++_iter1003) + std::vector ::const_iterator _iter1005; + for (_iter1005 = (*(this->part_vals)).begin(); _iter1005 != (*(this->part_vals)).end(); ++_iter1005) { - xfer += oprot->writeString((*_iter1003)); + xfer += oprot->writeString((*_iter1005)); } xfer += oprot->writeListEnd(); } @@ -12886,10 +12886,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((*(this->group_names)).size())); - std::vector ::const_iterator _iter1004; - for (_iter1004 = (*(this->group_names)).begin(); _iter1004 != (*(this->group_names)).end(); ++_iter1004) + std::vector ::const_iterator _iter1006; + for (_iter1006 = (*(this->group_names)).begin(); _iter1006 != (*(this->group_names)).end(); ++_iter1006) { - xfer += oprot->writeString((*_iter1004)); + xfer += oprot->writeString((*_iter1006)); } xfer += oprot->writeListEnd(); } @@ -13448,14 +13448,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1005; - ::apache::thrift::protocol::TType _etype1008; - xfer += iprot->readListBegin(_etype1008, _size1005); - this->success.resize(_size1005); - uint32_t _i1009; - for (_i1009 = 0; _i1009 < _size1005; ++_i1009) + uint32_t _size1007; + ::apache::thrift::protocol::TType _etype1010; + xfer += iprot->readListBegin(_etype1010, _size1007); + this->success.resize(_size1007); + uint32_t _i1011; + for (_i1011 = 0; _i1011 < _size1007; ++_i1011) { - xfer += this->success[_i1009].read(iprot); + xfer += this->success[_i1011].read(iprot); } xfer += iprot->readListEnd(); } @@ -13502,10 +13502,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(this->success.size())); - std::vector ::const_iterator _iter1010; - for (_iter1010 = this->success.begin(); _iter1010 != this->success.end(); ++_iter1010) + std::vector ::const_iterator _iter1012; + for (_iter1012 = this->success.begin(); _iter1012 != this->success.end(); ++_iter1012) { - xfer += (*_iter1010).write(oprot); + xfer += (*_iter1012).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13554,14 +13554,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1011; - ::apache::thrift::protocol::TType _etype1014; - xfer += iprot->readListBegin(_etype1014, _size1011); - (*(this->success)).resize(_size1011); - uint32_t _i1015; - for (_i1015 = 0; _i1015 < _size1011; ++_i1015) + uint32_t _size1013; + ::apache::thrift::protocol::TType _etype1016; + xfer += iprot->readListBegin(_etype1016, _size1013); + (*(this->success)).resize(_size1013); + uint32_t _i1017; + for (_i1017 = 0; _i1017 < _size1013; ++_i1017) { - xfer += (*(this->success))[_i1015].read(iprot); + xfer += (*(this->success))[_i1017].read(iprot); } xfer += iprot->readListEnd(); } @@ -13660,14 +13660,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 _size1016; - ::apache::thrift::protocol::TType _etype1019; - xfer += iprot->readListBegin(_etype1019, _size1016); - this->group_names.resize(_size1016); - uint32_t _i1020; - for (_i1020 = 0; _i1020 < _size1016; ++_i1020) + 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) { - xfer += iprot->readString(this->group_names[_i1020]); + xfer += iprot->readString(this->group_names[_i1022]); } xfer += iprot->readListEnd(); } @@ -13712,10 +13712,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(this->group_names.size())); - std::vector ::const_iterator _iter1021; - for (_iter1021 = this->group_names.begin(); _iter1021 != this->group_names.end(); ++_iter1021) + std::vector ::const_iterator _iter1023; + for (_iter1023 = this->group_names.begin(); _iter1023 != this->group_names.end(); ++_iter1023) { - xfer += oprot->writeString((*_iter1021)); + xfer += oprot->writeString((*_iter1023)); } xfer += oprot->writeListEnd(); } @@ -13755,10 +13755,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((*(this->group_names)).size())); - std::vector ::const_iterator _iter1022; - for (_iter1022 = (*(this->group_names)).begin(); _iter1022 != (*(this->group_names)).end(); ++_iter1022) + std::vector ::const_iterator _iter1024; + for (_iter1024 = (*(this->group_names)).begin(); _iter1024 != (*(this->group_names)).end(); ++_iter1024) { - xfer += oprot->writeString((*_iter1022)); + xfer += oprot->writeString((*_iter1024)); } xfer += oprot->writeListEnd(); } @@ -13799,14 +13799,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1023; - ::apache::thrift::protocol::TType _etype1026; - xfer += iprot->readListBegin(_etype1026, _size1023); - this->success.resize(_size1023); - uint32_t _i1027; - for (_i1027 = 0; _i1027 < _size1023; ++_i1027) + uint32_t _size1025; + ::apache::thrift::protocol::TType _etype1028; + xfer += iprot->readListBegin(_etype1028, _size1025); + this->success.resize(_size1025); + uint32_t _i1029; + for (_i1029 = 0; _i1029 < _size1025; ++_i1029) { - xfer += this->success[_i1027].read(iprot); + xfer += this->success[_i1029].read(iprot); } xfer += iprot->readListEnd(); } @@ -13853,10 +13853,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(this->success.size())); - std::vector ::const_iterator _iter1028; - for (_iter1028 = this->success.begin(); _iter1028 != this->success.end(); ++_iter1028) + std::vector ::const_iterator _iter1030; + for (_iter1030 = this->success.begin(); _iter1030 != this->success.end(); ++_iter1030) { - xfer += (*_iter1028).write(oprot); + xfer += (*_iter1030).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13905,14 +13905,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1031; + ::apache::thrift::protocol::TType _etype1034; + xfer += iprot->readListBegin(_etype1034, _size1031); + (*(this->success)).resize(_size1031); + uint32_t _i1035; + for (_i1035 = 0; _i1035 < _size1031; ++_i1035) { - xfer += (*(this->success))[_i1033].read(iprot); + xfer += (*(this->success))[_i1035].read(iprot); } xfer += iprot->readListEnd(); } @@ -14090,14 +14090,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1034; - ::apache::thrift::protocol::TType _etype1037; - xfer += iprot->readListBegin(_etype1037, _size1034); - this->success.resize(_size1034); - uint32_t _i1038; - for (_i1038 = 0; _i1038 < _size1034; ++_i1038) + uint32_t _size1036; + ::apache::thrift::protocol::TType _etype1039; + xfer += iprot->readListBegin(_etype1039, _size1036); + this->success.resize(_size1036); + uint32_t _i1040; + for (_i1040 = 0; _i1040 < _size1036; ++_i1040) { - xfer += this->success[_i1038].read(iprot); + xfer += this->success[_i1040].read(iprot); } xfer += iprot->readListEnd(); } @@ -14144,10 +14144,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(this->success.size())); - std::vector ::const_iterator _iter1039; - for (_iter1039 = this->success.begin(); _iter1039 != this->success.end(); ++_iter1039) + std::vector ::const_iterator _iter1041; + for (_iter1041 = this->success.begin(); _iter1041 != this->success.end(); ++_iter1041) { - xfer += (*_iter1039).write(oprot); + xfer += (*_iter1041).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14196,14 +14196,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1040; - ::apache::thrift::protocol::TType _etype1043; - xfer += iprot->readListBegin(_etype1043, _size1040); - (*(this->success)).resize(_size1040); - uint32_t _i1044; - for (_i1044 = 0; _i1044 < _size1040; ++_i1044) + uint32_t _size1042; + ::apache::thrift::protocol::TType _etype1045; + xfer += iprot->readListBegin(_etype1045, _size1042); + (*(this->success)).resize(_size1042); + uint32_t _i1046; + for (_i1046 = 0; _i1046 < _size1042; ++_i1046) { - xfer += (*(this->success))[_i1044].read(iprot); + xfer += (*(this->success))[_i1046].read(iprot); } xfer += iprot->readListEnd(); } @@ -14381,14 +14381,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift:: 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 += iprot->readString(this->success[_i1049]); + xfer += iprot->readString(this->success[_i1051]); } xfer += iprot->readListEnd(); } @@ -14427,10 +14427,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::write(::apache::thrift: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1050; - for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) + std::vector ::const_iterator _iter1052; + for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052) { - xfer += oprot->writeString((*_iter1050)); + xfer += oprot->writeString((*_iter1052)); } xfer += oprot->writeListEnd(); } @@ -14475,14 +14475,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift: 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 += iprot->readString((*(this->success))[_i1055]); + xfer += iprot->readString((*(this->success))[_i1057]); } xfer += iprot->readListEnd(); } @@ -14557,14 +14557,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->part_vals.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1058; + ::apache::thrift::protocol::TType _etype1061; + xfer += iprot->readListBegin(_etype1061, _size1058); + this->part_vals.resize(_size1058); + uint32_t _i1062; + for (_i1062 = 0; _i1062 < _size1058; ++_i1062) { - xfer += iprot->readString(this->part_vals[_i1060]); + xfer += iprot->readString(this->part_vals[_i1062]); } xfer += iprot->readListEnd(); } @@ -14609,10 +14609,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::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(this->part_vals.size())); - std::vector ::const_iterator _iter1061; - for (_iter1061 = this->part_vals.begin(); _iter1061 != this->part_vals.end(); ++_iter1061) + std::vector ::const_iterator _iter1063; + for (_iter1063 = this->part_vals.begin(); _iter1063 != this->part_vals.end(); ++_iter1063) { - xfer += oprot->writeString((*_iter1061)); + xfer += oprot->writeString((*_iter1063)); } xfer += oprot->writeListEnd(); } @@ -14648,10 +14648,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1062; - for (_iter1062 = (*(this->part_vals)).begin(); _iter1062 != (*(this->part_vals)).end(); ++_iter1062) + std::vector ::const_iterator _iter1064; + for (_iter1064 = (*(this->part_vals)).begin(); _iter1064 != (*(this->part_vals)).end(); ++_iter1064) { - xfer += oprot->writeString((*_iter1062)); + xfer += oprot->writeString((*_iter1064)); } xfer += oprot->writeListEnd(); } @@ -14696,14 +14696,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1063; - ::apache::thrift::protocol::TType _etype1066; - xfer += iprot->readListBegin(_etype1066, _size1063); - this->success.resize(_size1063); - uint32_t _i1067; - for (_i1067 = 0; _i1067 < _size1063; ++_i1067) + uint32_t _size1065; + ::apache::thrift::protocol::TType _etype1068; + xfer += iprot->readListBegin(_etype1068, _size1065); + this->success.resize(_size1065); + uint32_t _i1069; + for (_i1069 = 0; _i1069 < _size1065; ++_i1069) { - xfer += this->success[_i1067].read(iprot); + xfer += this->success[_i1069].read(iprot); } xfer += iprot->readListEnd(); } @@ -14750,10 +14750,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1068; - for (_iter1068 = this->success.begin(); _iter1068 != this->success.end(); ++_iter1068) + std::vector ::const_iterator _iter1070; + for (_iter1070 = this->success.begin(); _iter1070 != this->success.end(); ++_iter1070) { - xfer += (*_iter1068).write(oprot); + xfer += (*_iter1070).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14802,14 +14802,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - 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) + uint32_t _size1071; + ::apache::thrift::protocol::TType _etype1074; + xfer += iprot->readListBegin(_etype1074, _size1071); + (*(this->success)).resize(_size1071); + uint32_t _i1075; + for (_i1075 = 0; _i1075 < _size1071; ++_i1075) { - xfer += (*(this->success))[_i1073].read(iprot); + xfer += (*(this->success))[_i1075].read(iprot); } xfer += iprot->readListEnd(); } @@ -14892,14 +14892,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1074; - ::apache::thrift::protocol::TType _etype1077; - xfer += iprot->readListBegin(_etype1077, _size1074); - this->part_vals.resize(_size1074); - uint32_t _i1078; - for (_i1078 = 0; _i1078 < _size1074; ++_i1078) + uint32_t _size1076; + ::apache::thrift::protocol::TType _etype1079; + xfer += iprot->readListBegin(_etype1079, _size1076); + this->part_vals.resize(_size1076); + uint32_t _i1080; + for (_i1080 = 0; _i1080 < _size1076; ++_i1080) { - xfer += iprot->readString(this->part_vals[_i1078]); + xfer += iprot->readString(this->part_vals[_i1080]); } xfer += iprot->readListEnd(); } @@ -14928,14 +14928,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1079; - ::apache::thrift::protocol::TType _etype1082; - xfer += iprot->readListBegin(_etype1082, _size1079); - this->group_names.resize(_size1079); - uint32_t _i1083; - for (_i1083 = 0; _i1083 < _size1079; ++_i1083) + uint32_t _size1081; + ::apache::thrift::protocol::TType _etype1084; + xfer += iprot->readListBegin(_etype1084, _size1081); + this->group_names.resize(_size1081); + uint32_t _i1085; + for (_i1085 = 0; _i1085 < _size1081; ++_i1085) { - xfer += iprot->readString(this->group_names[_i1083]); + xfer += iprot->readString(this->group_names[_i1085]); } xfer += iprot->readListEnd(); } @@ -14972,10 +14972,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1084; - for (_iter1084 = this->part_vals.begin(); _iter1084 != this->part_vals.end(); ++_iter1084) + std::vector ::const_iterator _iter1086; + for (_iter1086 = this->part_vals.begin(); _iter1086 != this->part_vals.end(); ++_iter1086) { - xfer += oprot->writeString((*_iter1084)); + xfer += oprot->writeString((*_iter1086)); } xfer += oprot->writeListEnd(); } @@ -14992,10 +14992,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1085; - for (_iter1085 = this->group_names.begin(); _iter1085 != this->group_names.end(); ++_iter1085) + std::vector ::const_iterator _iter1087; + for (_iter1087 = this->group_names.begin(); _iter1087 != this->group_names.end(); ++_iter1087) { - xfer += oprot->writeString((*_iter1085)); + xfer += oprot->writeString((*_iter1087)); } xfer += oprot->writeListEnd(); } @@ -15027,10 +15027,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1086; - for (_iter1086 = (*(this->part_vals)).begin(); _iter1086 != (*(this->part_vals)).end(); ++_iter1086) + std::vector ::const_iterator _iter1088; + for (_iter1088 = (*(this->part_vals)).begin(); _iter1088 != (*(this->part_vals)).end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1086)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -15047,10 +15047,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache:: xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1087; - for (_iter1087 = (*(this->group_names)).begin(); _iter1087 != (*(this->group_names)).end(); ++_iter1087) + std::vector ::const_iterator _iter1089; + for (_iter1089 = (*(this->group_names)).begin(); _iter1089 != (*(this->group_names)).end(); ++_iter1089) { - xfer += oprot->writeString((*_iter1087)); + xfer += oprot->writeString((*_iter1089)); } xfer += oprot->writeListEnd(); } @@ -15091,14 +15091,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - this->success.resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1090; + ::apache::thrift::protocol::TType _etype1093; + xfer += iprot->readListBegin(_etype1093, _size1090); + this->success.resize(_size1090); + uint32_t _i1094; + for (_i1094 = 0; _i1094 < _size1090; ++_i1094) { - xfer += this->success[_i1092].read(iprot); + xfer += this->success[_i1094].read(iprot); } xfer += iprot->readListEnd(); } @@ -15145,10 +15145,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1093; - for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) + std::vector ::const_iterator _iter1095; + for (_iter1095 = this->success.begin(); _iter1095 != this->success.end(); ++_iter1095) { - xfer += (*_iter1093).write(oprot); + xfer += (*_iter1095).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15197,14 +15197,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1094; - ::apache::thrift::protocol::TType _etype1097; - xfer += iprot->readListBegin(_etype1097, _size1094); - (*(this->success)).resize(_size1094); - uint32_t _i1098; - for (_i1098 = 0; _i1098 < _size1094; ++_i1098) + uint32_t _size1096; + ::apache::thrift::protocol::TType _etype1099; + xfer += iprot->readListBegin(_etype1099, _size1096); + (*(this->success)).resize(_size1096); + uint32_t _i1100; + for (_i1100 = 0; _i1100 < _size1096; ++_i1100) { - xfer += (*(this->success))[_i1098].read(iprot); + xfer += (*(this->success))[_i1100].read(iprot); } xfer += iprot->readListEnd(); } @@ -15287,14 +15287,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1099; - ::apache::thrift::protocol::TType _etype1102; - xfer += iprot->readListBegin(_etype1102, _size1099); - this->part_vals.resize(_size1099); - uint32_t _i1103; - for (_i1103 = 0; _i1103 < _size1099; ++_i1103) + uint32_t _size1101; + ::apache::thrift::protocol::TType _etype1104; + xfer += iprot->readListBegin(_etype1104, _size1101); + this->part_vals.resize(_size1101); + uint32_t _i1105; + for (_i1105 = 0; _i1105 < _size1101; ++_i1105) { - xfer += iprot->readString(this->part_vals[_i1103]); + xfer += iprot->readString(this->part_vals[_i1105]); } xfer += iprot->readListEnd(); } @@ -15339,10 +15339,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1104; - for (_iter1104 = this->part_vals.begin(); _iter1104 != this->part_vals.end(); ++_iter1104) + std::vector ::const_iterator _iter1106; + for (_iter1106 = this->part_vals.begin(); _iter1106 != this->part_vals.end(); ++_iter1106) { - xfer += oprot->writeString((*_iter1104)); + xfer += oprot->writeString((*_iter1106)); } xfer += oprot->writeListEnd(); } @@ -15378,10 +15378,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1105; - for (_iter1105 = (*(this->part_vals)).begin(); _iter1105 != (*(this->part_vals)).end(); ++_iter1105) + std::vector ::const_iterator _iter1107; + for (_iter1107 = (*(this->part_vals)).begin(); _iter1107 != (*(this->part_vals)).end(); ++_iter1107) { - xfer += oprot->writeString((*_iter1105)); + xfer += oprot->writeString((*_iter1107)); } xfer += oprot->writeListEnd(); } @@ -15426,14 +15426,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1106; - ::apache::thrift::protocol::TType _etype1109; - xfer += iprot->readListBegin(_etype1109, _size1106); - this->success.resize(_size1106); - uint32_t _i1110; - for (_i1110 = 0; _i1110 < _size1106; ++_i1110) + uint32_t _size1108; + ::apache::thrift::protocol::TType _etype1111; + xfer += iprot->readListBegin(_etype1111, _size1108); + this->success.resize(_size1108); + uint32_t _i1112; + for (_i1112 = 0; _i1112 < _size1108; ++_i1112) { - xfer += iprot->readString(this->success[_i1110]); + xfer += iprot->readString(this->success[_i1112]); } xfer += iprot->readListEnd(); } @@ -15480,10 +15480,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1111; - for (_iter1111 = this->success.begin(); _iter1111 != this->success.end(); ++_iter1111) + std::vector ::const_iterator _iter1113; + for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) { - xfer += oprot->writeString((*_iter1111)); + xfer += oprot->writeString((*_iter1113)); } xfer += oprot->writeListEnd(); } @@ -15532,14 +15532,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1112; - ::apache::thrift::protocol::TType _etype1115; - xfer += iprot->readListBegin(_etype1115, _size1112); - (*(this->success)).resize(_size1112); - uint32_t _i1116; - for (_i1116 = 0; _i1116 < _size1112; ++_i1116) + uint32_t _size1114; + ::apache::thrift::protocol::TType _etype1117; + xfer += iprot->readListBegin(_etype1117, _size1114); + (*(this->success)).resize(_size1114); + uint32_t _i1118; + for (_i1118 = 0; _i1118 < _size1114; ++_i1118) { - xfer += iprot->readString((*(this->success))[_i1116]); + xfer += iprot->readString((*(this->success))[_i1118]); } xfer += iprot->readListEnd(); } @@ -15733,14 +15733,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1117; - ::apache::thrift::protocol::TType _etype1120; - xfer += iprot->readListBegin(_etype1120, _size1117); - this->success.resize(_size1117); - uint32_t _i1121; - for (_i1121 = 0; _i1121 < _size1117; ++_i1121) + uint32_t _size1119; + ::apache::thrift::protocol::TType _etype1122; + xfer += iprot->readListBegin(_etype1122, _size1119); + this->success.resize(_size1119); + uint32_t _i1123; + for (_i1123 = 0; _i1123 < _size1119; ++_i1123) { - xfer += this->success[_i1121].read(iprot); + xfer += this->success[_i1123].read(iprot); } xfer += iprot->readListEnd(); } @@ -15787,10 +15787,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1122; - for (_iter1122 = this->success.begin(); _iter1122 != this->success.end(); ++_iter1122) + std::vector ::const_iterator _iter1124; + for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) { - xfer += (*_iter1122).write(oprot); + xfer += (*_iter1124).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15839,14 +15839,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1123; - ::apache::thrift::protocol::TType _etype1126; - xfer += iprot->readListBegin(_etype1126, _size1123); - (*(this->success)).resize(_size1123); - uint32_t _i1127; - for (_i1127 = 0; _i1127 < _size1123; ++_i1127) + uint32_t _size1125; + ::apache::thrift::protocol::TType _etype1128; + xfer += iprot->readListBegin(_etype1128, _size1125); + (*(this->success)).resize(_size1125); + uint32_t _i1129; + for (_i1129 = 0; _i1129 < _size1125; ++_i1129) { - xfer += (*(this->success))[_i1127].read(iprot); + xfer += (*(this->success))[_i1129].read(iprot); } xfer += iprot->readListEnd(); } @@ -16040,14 +16040,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1128; - ::apache::thrift::protocol::TType _etype1131; - xfer += iprot->readListBegin(_etype1131, _size1128); - this->success.resize(_size1128); - uint32_t _i1132; - for (_i1132 = 0; _i1132 < _size1128; ++_i1132) + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + this->success.resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += this->success[_i1132].read(iprot); + xfer += this->success[_i1134].read(iprot); } xfer += iprot->readListEnd(); } @@ -16094,10 +16094,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1133; - for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) + std::vector ::const_iterator _iter1135; + for (_iter1135 = this->success.begin(); _iter1135 != this->success.end(); ++_iter1135) { - xfer += (*_iter1133).write(oprot); + xfer += (*_iter1135).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16146,14 +16146,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1134; - ::apache::thrift::protocol::TType _etype1137; - xfer += iprot->readListBegin(_etype1137, _size1134); - (*(this->success)).resize(_size1134); - uint32_t _i1138; - for (_i1138 = 0; _i1138 < _size1134; ++_i1138) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + (*(this->success)).resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += (*(this->success))[_i1138].read(iprot); + xfer += (*(this->success))[_i1140].read(iprot); } xfer += iprot->readListEnd(); } @@ -16722,14 +16722,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size1139; - ::apache::thrift::protocol::TType _etype1142; - xfer += iprot->readListBegin(_etype1142, _size1139); - this->names.resize(_size1139); - uint32_t _i1143; - for (_i1143 = 0; _i1143 < _size1139; ++_i1143) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->names.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += iprot->readString(this->names[_i1143]); + xfer += iprot->readString(this->names[_i1145]); } xfer += iprot->readListEnd(); } @@ -16766,10 +16766,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter1144; - for (_iter1144 = this->names.begin(); _iter1144 != this->names.end(); ++_iter1144) + std::vector ::const_iterator _iter1146; + for (_iter1146 = this->names.begin(); _iter1146 != this->names.end(); ++_iter1146) { - xfer += oprot->writeString((*_iter1144)); + xfer += oprot->writeString((*_iter1146)); } xfer += oprot->writeListEnd(); } @@ -16801,10 +16801,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->names)).size())); - std::vector ::const_iterator _iter1145; - for (_iter1145 = (*(this->names)).begin(); _iter1145 != (*(this->names)).end(); ++_iter1145) + std::vector ::const_iterator _iter1147; + for (_iter1147 = (*(this->names)).begin(); _iter1147 != (*(this->names)).end(); ++_iter1147) { - xfer += oprot->writeString((*_iter1145)); + xfer += oprot->writeString((*_iter1147)); } xfer += oprot->writeListEnd(); } @@ -16845,14 +16845,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1146; - ::apache::thrift::protocol::TType _etype1149; - xfer += iprot->readListBegin(_etype1149, _size1146); - this->success.resize(_size1146); - uint32_t _i1150; - for (_i1150 = 0; _i1150 < _size1146; ++_i1150) + uint32_t _size1148; + ::apache::thrift::protocol::TType _etype1151; + xfer += iprot->readListBegin(_etype1151, _size1148); + this->success.resize(_size1148); + uint32_t _i1152; + for (_i1152 = 0; _i1152 < _size1148; ++_i1152) { - xfer += this->success[_i1150].read(iprot); + xfer += this->success[_i1152].read(iprot); } xfer += iprot->readListEnd(); } @@ -16899,10 +16899,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1151; - for (_iter1151 = this->success.begin(); _iter1151 != this->success.end(); ++_iter1151) + std::vector ::const_iterator _iter1153; + for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) { - xfer += (*_iter1151).write(oprot); + xfer += (*_iter1153).write(oprot); } xfer += oprot->writeListEnd(); } @@ -16951,14 +16951,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1152; - ::apache::thrift::protocol::TType _etype1155; - xfer += iprot->readListBegin(_etype1155, _size1152); - (*(this->success)).resize(_size1152); - uint32_t _i1156; - for (_i1156 = 0; _i1156 < _size1152; ++_i1156) + uint32_t _size1154; + ::apache::thrift::protocol::TType _etype1157; + xfer += iprot->readListBegin(_etype1157, _size1154); + (*(this->success)).resize(_size1154); + uint32_t _i1158; + for (_i1158 = 0; _i1158 < _size1154; ++_i1158) { - xfer += (*(this->success))[_i1156].read(iprot); + xfer += (*(this->success))[_i1158].read(iprot); } xfer += iprot->readListEnd(); } @@ -17280,14 +17280,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1157; - ::apache::thrift::protocol::TType _etype1160; - xfer += iprot->readListBegin(_etype1160, _size1157); - this->new_parts.resize(_size1157); - uint32_t _i1161; - for (_i1161 = 0; _i1161 < _size1157; ++_i1161) + uint32_t _size1159; + ::apache::thrift::protocol::TType _etype1162; + xfer += iprot->readListBegin(_etype1162, _size1159); + this->new_parts.resize(_size1159); + uint32_t _i1163; + for (_i1163 = 0; _i1163 < _size1159; ++_i1163) { - xfer += this->new_parts[_i1161].read(iprot); + xfer += this->new_parts[_i1163].read(iprot); } xfer += iprot->readListEnd(); } @@ -17324,10 +17324,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1162; - for (_iter1162 = this->new_parts.begin(); _iter1162 != this->new_parts.end(); ++_iter1162) + std::vector ::const_iterator _iter1164; + for (_iter1164 = this->new_parts.begin(); _iter1164 != this->new_parts.end(); ++_iter1164) { - xfer += (*_iter1162).write(oprot); + xfer += (*_iter1164).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17359,10 +17359,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1163; - for (_iter1163 = (*(this->new_parts)).begin(); _iter1163 != (*(this->new_parts)).end(); ++_iter1163) + std::vector ::const_iterator _iter1165; + for (_iter1165 = (*(this->new_parts)).begin(); _iter1165 != (*(this->new_parts)).end(); ++_iter1165) { - xfer += (*_iter1163).write(oprot); + xfer += (*_iter1165).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17547,14 +17547,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1164; - ::apache::thrift::protocol::TType _etype1167; - xfer += iprot->readListBegin(_etype1167, _size1164); - this->new_parts.resize(_size1164); - uint32_t _i1168; - for (_i1168 = 0; _i1168 < _size1164; ++_i1168) + uint32_t _size1166; + ::apache::thrift::protocol::TType _etype1169; + xfer += iprot->readListBegin(_etype1169, _size1166); + this->new_parts.resize(_size1166); + uint32_t _i1170; + for (_i1170 = 0; _i1170 < _size1166; ++_i1170) { - xfer += this->new_parts[_i1168].read(iprot); + xfer += this->new_parts[_i1170].read(iprot); } xfer += iprot->readListEnd(); } @@ -17599,10 +17599,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_args::wri xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->new_parts.size())); - std::vector ::const_iterator _iter1169; - for (_iter1169 = this->new_parts.begin(); _iter1169 != this->new_parts.end(); ++_iter1169) + std::vector ::const_iterator _iter1171; + for (_iter1171 = this->new_parts.begin(); _iter1171 != this->new_parts.end(); ++_iter1171) { - xfer += (*_iter1169).write(oprot); + xfer += (*_iter1171).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17638,10 +17638,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast((*(this->new_parts)).size())); - std::vector ::const_iterator _iter1170; - for (_iter1170 = (*(this->new_parts)).begin(); _iter1170 != (*(this->new_parts)).end(); ++_iter1170) + std::vector ::const_iterator _iter1172; + for (_iter1172 = (*(this->new_parts)).begin(); _iter1172 != (*(this->new_parts)).end(); ++_iter1172) { - xfer += (*_iter1170).write(oprot); + xfer += (*_iter1172).write(oprot); } xfer += oprot->writeListEnd(); } @@ -18085,14 +18085,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1171; - ::apache::thrift::protocol::TType _etype1174; - xfer += iprot->readListBegin(_etype1174, _size1171); - this->part_vals.resize(_size1171); - uint32_t _i1175; - for (_i1175 = 0; _i1175 < _size1171; ++_i1175) + uint32_t _size1173; + ::apache::thrift::protocol::TType _etype1176; + xfer += iprot->readListBegin(_etype1176, _size1173); + this->part_vals.resize(_size1173); + uint32_t _i1177; + for (_i1177 = 0; _i1177 < _size1173; ++_i1177) { - xfer += iprot->readString(this->part_vals[_i1175]); + xfer += iprot->readString(this->part_vals[_i1177]); } xfer += iprot->readListEnd(); } @@ -18137,10 +18137,10 @@ uint32_t ThriftHiveMetastore_rename_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(this->part_vals.size())); - std::vector ::const_iterator _iter1176; - for (_iter1176 = this->part_vals.begin(); _iter1176 != this->part_vals.end(); ++_iter1176) + std::vector ::const_iterator _iter1178; + for (_iter1178 = this->part_vals.begin(); _iter1178 != this->part_vals.end(); ++_iter1178) { - xfer += oprot->writeString((*_iter1176)); + xfer += oprot->writeString((*_iter1178)); } xfer += oprot->writeListEnd(); } @@ -18176,10 +18176,10 @@ uint32_t ThriftHiveMetastore_rename_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((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1177; - for (_iter1177 = (*(this->part_vals)).begin(); _iter1177 != (*(this->part_vals)).end(); ++_iter1177) + std::vector ::const_iterator _iter1179; + for (_iter1179 = (*(this->part_vals)).begin(); _iter1179 != (*(this->part_vals)).end(); ++_iter1179) { - xfer += oprot->writeString((*_iter1177)); + xfer += oprot->writeString((*_iter1179)); } xfer += oprot->writeListEnd(); } @@ -18352,14 +18352,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1178; - ::apache::thrift::protocol::TType _etype1181; - xfer += iprot->readListBegin(_etype1181, _size1178); - this->part_vals.resize(_size1178); - uint32_t _i1182; - for (_i1182 = 0; _i1182 < _size1178; ++_i1182) + uint32_t _size1180; + ::apache::thrift::protocol::TType _etype1183; + xfer += iprot->readListBegin(_etype1183, _size1180); + this->part_vals.resize(_size1180); + uint32_t _i1184; + for (_i1184 = 0; _i1184 < _size1180; ++_i1184) { - xfer += iprot->readString(this->part_vals[_i1182]); + xfer += iprot->readString(this->part_vals[_i1184]); } xfer += iprot->readListEnd(); } @@ -18396,10 +18396,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::vector ::const_iterator _iter1183; - for (_iter1183 = this->part_vals.begin(); _iter1183 != this->part_vals.end(); ++_iter1183) + std::vector ::const_iterator _iter1185; + for (_iter1185 = this->part_vals.begin(); _iter1185 != this->part_vals.end(); ++_iter1185) { - xfer += oprot->writeString((*_iter1183)); + xfer += oprot->writeString((*_iter1185)); } xfer += oprot->writeListEnd(); } @@ -18427,10 +18427,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(:: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::vector ::const_iterator _iter1184; - for (_iter1184 = (*(this->part_vals)).begin(); _iter1184 != (*(this->part_vals)).end(); ++_iter1184) + std::vector ::const_iterator _iter1186; + for (_iter1186 = (*(this->part_vals)).begin(); _iter1186 != (*(this->part_vals)).end(); ++_iter1186) { - xfer += oprot->writeString((*_iter1184)); + xfer += oprot->writeString((*_iter1186)); } xfer += oprot->writeListEnd(); } @@ -18905,14 +18905,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->success.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->success.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += iprot->readString(this->success[_i1189]); + xfer += iprot->readString(this->success[_i1191]); } xfer += iprot->readListEnd(); } @@ -18951,10 +18951,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1190; - for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190) + std::vector ::const_iterator _iter1192; + for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1190)); + xfer += oprot->writeString((*_iter1192)); } xfer += oprot->writeListEnd(); } @@ -18999,14 +18999,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1191; - ::apache::thrift::protocol::TType _etype1194; - xfer += iprot->readListBegin(_etype1194, _size1191); - (*(this->success)).resize(_size1191); - uint32_t _i1195; - for (_i1195 = 0; _i1195 < _size1191; ++_i1195) + uint32_t _size1193; + ::apache::thrift::protocol::TType _etype1196; + xfer += iprot->readListBegin(_etype1196, _size1193); + (*(this->success)).resize(_size1193); + uint32_t _i1197; + for (_i1197 = 0; _i1197 < _size1193; ++_i1197) { - xfer += iprot->readString((*(this->success))[_i1195]); + xfer += iprot->readString((*(this->success))[_i1197]); } xfer += iprot->readListEnd(); } @@ -19144,17 +19144,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1196; - ::apache::thrift::protocol::TType _ktype1197; - ::apache::thrift::protocol::TType _vtype1198; - xfer += iprot->readMapBegin(_ktype1197, _vtype1198, _size1196); - uint32_t _i1200; - for (_i1200 = 0; _i1200 < _size1196; ++_i1200) + uint32_t _size1198; + ::apache::thrift::protocol::TType _ktype1199; + ::apache::thrift::protocol::TType _vtype1200; + xfer += iprot->readMapBegin(_ktype1199, _vtype1200, _size1198); + uint32_t _i1202; + for (_i1202 = 0; _i1202 < _size1198; ++_i1202) { - std::string _key1201; - xfer += iprot->readString(_key1201); - std::string& _val1202 = this->success[_key1201]; - xfer += iprot->readString(_val1202); + std::string _key1203; + xfer += iprot->readString(_key1203); + std::string& _val1204 = this->success[_key1203]; + xfer += iprot->readString(_val1204); } xfer += iprot->readMapEnd(); } @@ -19193,11 +19193,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::map ::const_iterator _iter1203; - for (_iter1203 = this->success.begin(); _iter1203 != this->success.end(); ++_iter1203) + std::map ::const_iterator _iter1205; + for (_iter1205 = this->success.begin(); _iter1205 != this->success.end(); ++_iter1205) { - xfer += oprot->writeString(_iter1203->first); - xfer += oprot->writeString(_iter1203->second); + xfer += oprot->writeString(_iter1205->first); + xfer += oprot->writeString(_iter1205->second); } xfer += oprot->writeMapEnd(); } @@ -19242,17 +19242,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1204; - ::apache::thrift::protocol::TType _ktype1205; - ::apache::thrift::protocol::TType _vtype1206; - xfer += iprot->readMapBegin(_ktype1205, _vtype1206, _size1204); - uint32_t _i1208; - for (_i1208 = 0; _i1208 < _size1204; ++_i1208) + uint32_t _size1206; + ::apache::thrift::protocol::TType _ktype1207; + ::apache::thrift::protocol::TType _vtype1208; + xfer += iprot->readMapBegin(_ktype1207, _vtype1208, _size1206); + uint32_t _i1210; + for (_i1210 = 0; _i1210 < _size1206; ++_i1210) { - std::string _key1209; - xfer += iprot->readString(_key1209); - std::string& _val1210 = (*(this->success))[_key1209]; - xfer += iprot->readString(_val1210); + std::string _key1211; + xfer += iprot->readString(_key1211); + std::string& _val1212 = (*(this->success))[_key1211]; + xfer += iprot->readString(_val1212); } xfer += iprot->readMapEnd(); } @@ -19327,17 +19327,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1211; - ::apache::thrift::protocol::TType _ktype1212; - ::apache::thrift::protocol::TType _vtype1213; - xfer += iprot->readMapBegin(_ktype1212, _vtype1213, _size1211); - uint32_t _i1215; - for (_i1215 = 0; _i1215 < _size1211; ++_i1215) + uint32_t _size1213; + ::apache::thrift::protocol::TType _ktype1214; + ::apache::thrift::protocol::TType _vtype1215; + xfer += iprot->readMapBegin(_ktype1214, _vtype1215, _size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - std::string _key1216; - xfer += iprot->readString(_key1216); - std::string& _val1217 = this->part_vals[_key1216]; - xfer += iprot->readString(_val1217); + std::string _key1218; + xfer += iprot->readString(_key1218); + std::string& _val1219 = this->part_vals[_key1218]; + xfer += iprot->readString(_val1219); } xfer += iprot->readMapEnd(); } @@ -19348,9 +19348,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift:: break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1218; - xfer += iprot->readI32(ecast1218); - this->eventType = (PartitionEventType::type)ecast1218; + int32_t ecast1220; + xfer += iprot->readI32(ecast1220); + this->eventType = (PartitionEventType::type)ecast1220; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -19384,11 +19384,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift: xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1219; - for (_iter1219 = this->part_vals.begin(); _iter1219 != this->part_vals.end(); ++_iter1219) + std::map ::const_iterator _iter1221; + for (_iter1221 = this->part_vals.begin(); _iter1221 != this->part_vals.end(); ++_iter1221) { - xfer += oprot->writeString(_iter1219->first); - xfer += oprot->writeString(_iter1219->second); + xfer += oprot->writeString(_iter1221->first); + xfer += oprot->writeString(_iter1221->second); } xfer += oprot->writeMapEnd(); } @@ -19424,11 +19424,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1220; - for (_iter1220 = (*(this->part_vals)).begin(); _iter1220 != (*(this->part_vals)).end(); ++_iter1220) + std::map ::const_iterator _iter1222; + for (_iter1222 = (*(this->part_vals)).begin(); _iter1222 != (*(this->part_vals)).end(); ++_iter1222) { - xfer += oprot->writeString(_iter1220->first); - xfer += oprot->writeString(_iter1220->second); + xfer += oprot->writeString(_iter1222->first); + xfer += oprot->writeString(_iter1222->second); } xfer += oprot->writeMapEnd(); } @@ -19697,17 +19697,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_MAP) { { this->part_vals.clear(); - uint32_t _size1221; - ::apache::thrift::protocol::TType _ktype1222; - ::apache::thrift::protocol::TType _vtype1223; - xfer += iprot->readMapBegin(_ktype1222, _vtype1223, _size1221); - uint32_t _i1225; - for (_i1225 = 0; _i1225 < _size1221; ++_i1225) + uint32_t _size1223; + ::apache::thrift::protocol::TType _ktype1224; + ::apache::thrift::protocol::TType _vtype1225; + xfer += iprot->readMapBegin(_ktype1224, _vtype1225, _size1223); + uint32_t _i1227; + for (_i1227 = 0; _i1227 < _size1223; ++_i1227) { - std::string _key1226; - xfer += iprot->readString(_key1226); - std::string& _val1227 = this->part_vals[_key1226]; - xfer += iprot->readString(_val1227); + std::string _key1228; + xfer += iprot->readString(_key1228); + std::string& _val1229 = this->part_vals[_key1228]; + xfer += iprot->readString(_val1229); } xfer += iprot->readMapEnd(); } @@ -19718,9 +19718,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1228; - xfer += iprot->readI32(ecast1228); - this->eventType = (PartitionEventType::type)ecast1228; + int32_t ecast1230; + xfer += iprot->readI32(ecast1230); + this->eventType = (PartitionEventType::type)ecast1230; this->__isset.eventType = true; } else { xfer += iprot->skip(ftype); @@ -19754,11 +19754,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->part_vals.size())); - std::map ::const_iterator _iter1229; - for (_iter1229 = this->part_vals.begin(); _iter1229 != this->part_vals.end(); ++_iter1229) + std::map ::const_iterator _iter1231; + for (_iter1231 = this->part_vals.begin(); _iter1231 != this->part_vals.end(); ++_iter1231) { - xfer += oprot->writeString(_iter1229->first); - xfer += oprot->writeString(_iter1229->second); + xfer += oprot->writeString(_iter1231->first); + xfer += oprot->writeString(_iter1231->second); } xfer += oprot->writeMapEnd(); } @@ -19794,11 +19794,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast((*(this->part_vals)).size())); - std::map ::const_iterator _iter1230; - for (_iter1230 = (*(this->part_vals)).begin(); _iter1230 != (*(this->part_vals)).end(); ++_iter1230) + std::map ::const_iterator _iter1232; + for (_iter1232 = (*(this->part_vals)).begin(); _iter1232 != (*(this->part_vals)).end(); ++_iter1232) { - xfer += oprot->writeString(_iter1230->first); - xfer += oprot->writeString(_iter1230->second); + xfer += oprot->writeString(_iter1232->first); + xfer += oprot->writeString(_iter1232->second); } xfer += oprot->writeMapEnd(); } @@ -21234,14 +21234,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1231; - ::apache::thrift::protocol::TType _etype1234; - xfer += iprot->readListBegin(_etype1234, _size1231); - this->success.resize(_size1231); - uint32_t _i1235; - for (_i1235 = 0; _i1235 < _size1231; ++_i1235) + uint32_t _size1233; + ::apache::thrift::protocol::TType _etype1236; + xfer += iprot->readListBegin(_etype1236, _size1233); + this->success.resize(_size1233); + uint32_t _i1237; + for (_i1237 = 0; _i1237 < _size1233; ++_i1237) { - xfer += this->success[_i1235].read(iprot); + xfer += this->success[_i1237].read(iprot); } xfer += iprot->readListEnd(); } @@ -21288,10 +21288,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1236; - for (_iter1236 = this->success.begin(); _iter1236 != this->success.end(); ++_iter1236) + std::vector ::const_iterator _iter1238; + for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) { - xfer += (*_iter1236).write(oprot); + xfer += (*_iter1238).write(oprot); } xfer += oprot->writeListEnd(); } @@ -21340,14 +21340,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1237; - ::apache::thrift::protocol::TType _etype1240; - xfer += iprot->readListBegin(_etype1240, _size1237); - (*(this->success)).resize(_size1237); - uint32_t _i1241; - for (_i1241 = 0; _i1241 < _size1237; ++_i1241) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + (*(this->success)).resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += (*(this->success))[_i1241].read(iprot); + xfer += (*(this->success))[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -21525,14 +21525,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1242; - ::apache::thrift::protocol::TType _etype1245; - xfer += iprot->readListBegin(_etype1245, _size1242); - this->success.resize(_size1242); - uint32_t _i1246; - for (_i1246 = 0; _i1246 < _size1242; ++_i1246) + uint32_t _size1244; + ::apache::thrift::protocol::TType _etype1247; + xfer += iprot->readListBegin(_etype1247, _size1244); + this->success.resize(_size1244); + uint32_t _i1248; + for (_i1248 = 0; _i1248 < _size1244; ++_i1248) { - xfer += iprot->readString(this->success[_i1246]); + xfer += iprot->readString(this->success[_i1248]); } xfer += iprot->readListEnd(); } @@ -21571,10 +21571,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1247; - for (_iter1247 = this->success.begin(); _iter1247 != this->success.end(); ++_iter1247) + std::vector ::const_iterator _iter1249; + for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) { - xfer += oprot->writeString((*_iter1247)); + xfer += oprot->writeString((*_iter1249)); } xfer += oprot->writeListEnd(); } @@ -21619,14 +21619,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1248; - ::apache::thrift::protocol::TType _etype1251; - xfer += iprot->readListBegin(_etype1251, _size1248); - (*(this->success)).resize(_size1248); - uint32_t _i1252; - for (_i1252 = 0; _i1252 < _size1248; ++_i1252) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + (*(this->success)).resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString((*(this->success))[_i1252]); + xfer += iprot->readString((*(this->success))[_i1254]); } xfer += iprot->readListEnd(); } @@ -22644,6 +22644,273 @@ uint32_t ThriftHiveMetastore_update_partition_column_statistics_presult::read(:: } +ThriftHiveMetastore_renew_column_statistics_args::~ThriftHiveMetastore_renew_column_statistics_args() throw() { +} + + +uint32_t ThriftHiveMetastore_renew_column_statistics_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_STRUCT) { + xfer += this->request.read(iprot); + this->__isset.request = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_renew_column_statistics_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_column_statistics_args"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->request.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_column_statistics_pargs::~ThriftHiveMetastore_renew_column_statistics_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_renew_column_statistics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_column_statistics_pargs"); + + xfer += oprot->writeFieldBegin("request", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->request)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_column_statistics_result::~ThriftHiveMetastore_renew_column_statistics_result() throw() { +} + + +uint32_t ThriftHiveMetastore_renew_column_statistics_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 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->success); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + 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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_renew_column_statistics_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_renew_column_statistics_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0); + xfer += oprot->writeBool(this->success); + xfer += oprot->writeFieldEnd(); + } else 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(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o4) { + xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->o4.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_renew_column_statistics_presult::~ThriftHiveMetastore_renew_column_statistics_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_renew_column_statistics_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 0: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool((*(this->success))); + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + 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; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o4.read(iprot); + this->__isset.o4 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + ThriftHiveMetastore_get_table_column_statistics_args::~ThriftHiveMetastore_get_table_column_statistics_args() throw() { } @@ -25653,14 +25920,14 @@ uint32_t ThriftHiveMetastore_get_functions_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1253; - ::apache::thrift::protocol::TType _etype1256; - xfer += iprot->readListBegin(_etype1256, _size1253); - this->success.resize(_size1253); - uint32_t _i1257; - for (_i1257 = 0; _i1257 < _size1253; ++_i1257) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->success.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += iprot->readString(this->success[_i1257]); + xfer += iprot->readString(this->success[_i1259]); } xfer += iprot->readListEnd(); } @@ -25699,10 +25966,10 @@ uint32_t ThriftHiveMetastore_get_functions_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(this->success.size())); - std::vector ::const_iterator _iter1258; - for (_iter1258 = this->success.begin(); _iter1258 != this->success.end(); ++_iter1258) + std::vector ::const_iterator _iter1260; + for (_iter1260 = this->success.begin(); _iter1260 != this->success.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1258)); + xfer += oprot->writeString((*_iter1260)); } xfer += oprot->writeListEnd(); } @@ -25747,14 +26014,14 @@ uint32_t ThriftHiveMetastore_get_functions_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1259; - ::apache::thrift::protocol::TType _etype1262; - xfer += iprot->readListBegin(_etype1262, _size1259); - (*(this->success)).resize(_size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + (*(this->success)).resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += iprot->readString((*(this->success))[_i1263]); + xfer += iprot->readString((*(this->success))[_i1265]); } xfer += iprot->readListEnd(); } @@ -26714,14 +26981,14 @@ uint32_t ThriftHiveMetastore_get_role_names_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1264; - ::apache::thrift::protocol::TType _etype1267; - xfer += iprot->readListBegin(_etype1267, _size1264); - this->success.resize(_size1264); - uint32_t _i1268; - for (_i1268 = 0; _i1268 < _size1264; ++_i1268) + uint32_t _size1266; + ::apache::thrift::protocol::TType _etype1269; + xfer += iprot->readListBegin(_etype1269, _size1266); + this->success.resize(_size1266); + uint32_t _i1270; + for (_i1270 = 0; _i1270 < _size1266; ++_i1270) { - xfer += iprot->readString(this->success[_i1268]); + xfer += iprot->readString(this->success[_i1270]); } xfer += iprot->readListEnd(); } @@ -26760,10 +27027,10 @@ uint32_t ThriftHiveMetastore_get_role_names_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(this->success.size())); - std::vector ::const_iterator _iter1269; - for (_iter1269 = this->success.begin(); _iter1269 != this->success.end(); ++_iter1269) + std::vector ::const_iterator _iter1271; + for (_iter1271 = this->success.begin(); _iter1271 != this->success.end(); ++_iter1271) { - xfer += oprot->writeString((*_iter1269)); + xfer += oprot->writeString((*_iter1271)); } xfer += oprot->writeListEnd(); } @@ -26808,14 +27075,14 @@ uint32_t ThriftHiveMetastore_get_role_names_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1270; - ::apache::thrift::protocol::TType _etype1273; - xfer += iprot->readListBegin(_etype1273, _size1270); - (*(this->success)).resize(_size1270); - uint32_t _i1274; - for (_i1274 = 0; _i1274 < _size1270; ++_i1274) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + (*(this->success)).resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += iprot->readString((*(this->success))[_i1274]); + xfer += iprot->readString((*(this->success))[_i1276]); } xfer += iprot->readListEnd(); } @@ -26888,9 +27155,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1275; - xfer += iprot->readI32(ecast1275); - this->principal_type = (PrincipalType::type)ecast1275; + int32_t ecast1277; + xfer += iprot->readI32(ecast1277); + this->principal_type = (PrincipalType::type)ecast1277; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -26906,9 +27173,9 @@ uint32_t ThriftHiveMetastore_grant_role_args::read(::apache::thrift::protocol::T break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1276; - xfer += iprot->readI32(ecast1276); - this->grantorType = (PrincipalType::type)ecast1276; + int32_t ecast1278; + xfer += iprot->readI32(ecast1278); + this->grantorType = (PrincipalType::type)ecast1278; this->__isset.grantorType = true; } else { xfer += iprot->skip(ftype); @@ -27179,9 +27446,9 @@ uint32_t ThriftHiveMetastore_revoke_role_args::read(::apache::thrift::protocol:: break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1277; - xfer += iprot->readI32(ecast1277); - this->principal_type = (PrincipalType::type)ecast1277; + int32_t ecast1279; + xfer += iprot->readI32(ecast1279); + this->principal_type = (PrincipalType::type)ecast1279; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -27412,9 +27679,9 @@ uint32_t ThriftHiveMetastore_list_roles_args::read(::apache::thrift::protocol::T break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1278; - xfer += iprot->readI32(ecast1278); - this->principal_type = (PrincipalType::type)ecast1278; + int32_t ecast1280; + xfer += iprot->readI32(ecast1280); + this->principal_type = (PrincipalType::type)ecast1280; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -27503,14 +27770,14 @@ uint32_t ThriftHiveMetastore_list_roles_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1279; - ::apache::thrift::protocol::TType _etype1282; - xfer += iprot->readListBegin(_etype1282, _size1279); - this->success.resize(_size1279); - uint32_t _i1283; - for (_i1283 = 0; _i1283 < _size1279; ++_i1283) + uint32_t _size1281; + ::apache::thrift::protocol::TType _etype1284; + xfer += iprot->readListBegin(_etype1284, _size1281); + this->success.resize(_size1281); + uint32_t _i1285; + for (_i1285 = 0; _i1285 < _size1281; ++_i1285) { - xfer += this->success[_i1283].read(iprot); + xfer += this->success[_i1285].read(iprot); } xfer += iprot->readListEnd(); } @@ -27549,10 +27816,10 @@ uint32_t ThriftHiveMetastore_list_roles_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(this->success.size())); - std::vector ::const_iterator _iter1284; - for (_iter1284 = this->success.begin(); _iter1284 != this->success.end(); ++_iter1284) + std::vector ::const_iterator _iter1286; + for (_iter1286 = this->success.begin(); _iter1286 != this->success.end(); ++_iter1286) { - xfer += (*_iter1284).write(oprot); + xfer += (*_iter1286).write(oprot); } xfer += oprot->writeListEnd(); } @@ -27597,14 +27864,14 @@ uint32_t ThriftHiveMetastore_list_roles_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1285; - ::apache::thrift::protocol::TType _etype1288; - xfer += iprot->readListBegin(_etype1288, _size1285); - (*(this->success)).resize(_size1285); - uint32_t _i1289; - for (_i1289 = 0; _i1289 < _size1285; ++_i1289) + uint32_t _size1287; + ::apache::thrift::protocol::TType _etype1290; + xfer += iprot->readListBegin(_etype1290, _size1287); + (*(this->success)).resize(_size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - xfer += (*(this->success))[_i1289].read(iprot); + xfer += (*(this->success))[_i1291].read(iprot); } xfer += iprot->readListEnd(); } @@ -28300,14 +28567,14 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1290; - ::apache::thrift::protocol::TType _etype1293; - xfer += iprot->readListBegin(_etype1293, _size1290); - this->group_names.resize(_size1290); - uint32_t _i1294; - for (_i1294 = 0; _i1294 < _size1290; ++_i1294) + uint32_t _size1292; + ::apache::thrift::protocol::TType _etype1295; + xfer += iprot->readListBegin(_etype1295, _size1292); + this->group_names.resize(_size1292); + uint32_t _i1296; + for (_i1296 = 0; _i1296 < _size1292; ++_i1296) { - xfer += iprot->readString(this->group_names[_i1294]); + xfer += iprot->readString(this->group_names[_i1296]); } xfer += iprot->readListEnd(); } @@ -28344,10 +28611,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_args::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1295; - for (_iter1295 = this->group_names.begin(); _iter1295 != this->group_names.end(); ++_iter1295) + std::vector ::const_iterator _iter1297; + for (_iter1297 = this->group_names.begin(); _iter1297 != this->group_names.end(); ++_iter1297) { - xfer += oprot->writeString((*_iter1295)); + xfer += oprot->writeString((*_iter1297)); } xfer += oprot->writeListEnd(); } @@ -28379,10 +28646,10 @@ uint32_t ThriftHiveMetastore_get_privilege_set_pargs::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1296; - for (_iter1296 = (*(this->group_names)).begin(); _iter1296 != (*(this->group_names)).end(); ++_iter1296) + std::vector ::const_iterator _iter1298; + for (_iter1298 = (*(this->group_names)).begin(); _iter1298 != (*(this->group_names)).end(); ++_iter1298) { - xfer += oprot->writeString((*_iter1296)); + xfer += oprot->writeString((*_iter1298)); } xfer += oprot->writeListEnd(); } @@ -28557,9 +28824,9 @@ uint32_t ThriftHiveMetastore_list_privileges_args::read(::apache::thrift::protoc break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast1297; - xfer += iprot->readI32(ecast1297); - this->principal_type = (PrincipalType::type)ecast1297; + int32_t ecast1299; + xfer += iprot->readI32(ecast1299); + this->principal_type = (PrincipalType::type)ecast1299; this->__isset.principal_type = true; } else { xfer += iprot->skip(ftype); @@ -28664,14 +28931,14 @@ uint32_t ThriftHiveMetastore_list_privileges_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1298; - ::apache::thrift::protocol::TType _etype1301; - xfer += iprot->readListBegin(_etype1301, _size1298); - this->success.resize(_size1298); - uint32_t _i1302; - for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + uint32_t _size1300; + ::apache::thrift::protocol::TType _etype1303; + xfer += iprot->readListBegin(_etype1303, _size1300); + this->success.resize(_size1300); + uint32_t _i1304; + for (_i1304 = 0; _i1304 < _size1300; ++_i1304) { - xfer += this->success[_i1302].read(iprot); + xfer += this->success[_i1304].read(iprot); } xfer += iprot->readListEnd(); } @@ -28710,10 +28977,10 @@ uint32_t ThriftHiveMetastore_list_privileges_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->success.size())); - std::vector ::const_iterator _iter1303; - for (_iter1303 = this->success.begin(); _iter1303 != this->success.end(); ++_iter1303) + std::vector ::const_iterator _iter1305; + for (_iter1305 = this->success.begin(); _iter1305 != this->success.end(); ++_iter1305) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1305).write(oprot); } xfer += oprot->writeListEnd(); } @@ -28758,14 +29025,14 @@ uint32_t ThriftHiveMetastore_list_privileges_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1304; - ::apache::thrift::protocol::TType _etype1307; - xfer += iprot->readListBegin(_etype1307, _size1304); - (*(this->success)).resize(_size1304); - uint32_t _i1308; - for (_i1308 = 0; _i1308 < _size1304; ++_i1308) + uint32_t _size1306; + ::apache::thrift::protocol::TType _etype1309; + xfer += iprot->readListBegin(_etype1309, _size1306); + (*(this->success)).resize(_size1306); + uint32_t _i1310; + for (_i1310 = 0; _i1310 < _size1306; ++_i1310) { - xfer += (*(this->success))[_i1308].read(iprot); + xfer += (*(this->success))[_i1310].read(iprot); } xfer += iprot->readListEnd(); } @@ -29453,14 +29720,14 @@ uint32_t ThriftHiveMetastore_set_ugi_args::read(::apache::thrift::protocol::TPro if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1309; - ::apache::thrift::protocol::TType _etype1312; - xfer += iprot->readListBegin(_etype1312, _size1309); - this->group_names.resize(_size1309); - uint32_t _i1313; - for (_i1313 = 0; _i1313 < _size1309; ++_i1313) + uint32_t _size1311; + ::apache::thrift::protocol::TType _etype1314; + xfer += iprot->readListBegin(_etype1314, _size1311); + this->group_names.resize(_size1311); + uint32_t _i1315; + for (_i1315 = 0; _i1315 < _size1311; ++_i1315) { - xfer += iprot->readString(this->group_names[_i1313]); + xfer += iprot->readString(this->group_names[_i1315]); } xfer += iprot->readListEnd(); } @@ -29493,10 +29760,10 @@ uint32_t ThriftHiveMetastore_set_ugi_args::write(::apache::thrift::protocol::TPr xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->group_names.size())); - std::vector ::const_iterator _iter1314; - for (_iter1314 = this->group_names.begin(); _iter1314 != this->group_names.end(); ++_iter1314) + std::vector ::const_iterator _iter1316; + for (_iter1316 = this->group_names.begin(); _iter1316 != this->group_names.end(); ++_iter1316) { - xfer += oprot->writeString((*_iter1314)); + xfer += oprot->writeString((*_iter1316)); } xfer += oprot->writeListEnd(); } @@ -29524,10 +29791,10 @@ uint32_t ThriftHiveMetastore_set_ugi_pargs::write(::apache::thrift::protocol::TP xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast((*(this->group_names)).size())); - std::vector ::const_iterator _iter1315; - for (_iter1315 = (*(this->group_names)).begin(); _iter1315 != (*(this->group_names)).end(); ++_iter1315) + std::vector ::const_iterator _iter1317; + for (_iter1317 = (*(this->group_names)).begin(); _iter1317 != (*(this->group_names)).end(); ++_iter1317) { - xfer += oprot->writeString((*_iter1315)); + xfer += oprot->writeString((*_iter1317)); } xfer += oprot->writeListEnd(); } @@ -29568,14 +29835,14 @@ uint32_t ThriftHiveMetastore_set_ugi_result::read(::apache::thrift::protocol::TP if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1316; - ::apache::thrift::protocol::TType _etype1319; - xfer += iprot->readListBegin(_etype1319, _size1316); - this->success.resize(_size1316); - uint32_t _i1320; - for (_i1320 = 0; _i1320 < _size1316; ++_i1320) + uint32_t _size1318; + ::apache::thrift::protocol::TType _etype1321; + xfer += iprot->readListBegin(_etype1321, _size1318); + this->success.resize(_size1318); + uint32_t _i1322; + for (_i1322 = 0; _i1322 < _size1318; ++_i1322) { - xfer += iprot->readString(this->success[_i1320]); + xfer += iprot->readString(this->success[_i1322]); } xfer += iprot->readListEnd(); } @@ -29614,10 +29881,10 @@ uint32_t ThriftHiveMetastore_set_ugi_result::write(::apache::thrift::protocol::T xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1321; - for (_iter1321 = this->success.begin(); _iter1321 != this->success.end(); ++_iter1321) + std::vector ::const_iterator _iter1323; + for (_iter1323 = this->success.begin(); _iter1323 != this->success.end(); ++_iter1323) { - xfer += oprot->writeString((*_iter1321)); + xfer += oprot->writeString((*_iter1323)); } xfer += oprot->writeListEnd(); } @@ -29662,14 +29929,14 @@ uint32_t ThriftHiveMetastore_set_ugi_presult::read(::apache::thrift::protocol::T if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1322; - ::apache::thrift::protocol::TType _etype1325; - xfer += iprot->readListBegin(_etype1325, _size1322); - (*(this->success)).resize(_size1322); - uint32_t _i1326; - for (_i1326 = 0; _i1326 < _size1322; ++_i1326) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + (*(this->success)).resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += iprot->readString((*(this->success))[_i1326]); + xfer += iprot->readString((*(this->success))[_i1328]); } xfer += iprot->readListEnd(); } @@ -30980,14 +31247,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1327; - ::apache::thrift::protocol::TType _etype1330; - xfer += iprot->readListBegin(_etype1330, _size1327); - this->success.resize(_size1327); - uint32_t _i1331; - for (_i1331 = 0; _i1331 < _size1327; ++_i1331) + uint32_t _size1329; + ::apache::thrift::protocol::TType _etype1332; + xfer += iprot->readListBegin(_etype1332, _size1329); + this->success.resize(_size1329); + uint32_t _i1333; + for (_i1333 = 0; _i1333 < _size1329; ++_i1333) { - xfer += iprot->readString(this->success[_i1331]); + xfer += iprot->readString(this->success[_i1333]); } xfer += iprot->readListEnd(); } @@ -31018,10 +31285,10 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1332; - for (_iter1332 = this->success.begin(); _iter1332 != this->success.end(); ++_iter1332) + std::vector ::const_iterator _iter1334; + for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1332)); + xfer += oprot->writeString((*_iter1334)); } xfer += oprot->writeListEnd(); } @@ -31062,14 +31329,14 @@ uint32_t ThriftHiveMetastore_get_all_token_identifiers_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1333; - ::apache::thrift::protocol::TType _etype1336; - xfer += iprot->readListBegin(_etype1336, _size1333); - (*(this->success)).resize(_size1333); - uint32_t _i1337; - for (_i1337 = 0; _i1337 < _size1333; ++_i1337) + uint32_t _size1335; + ::apache::thrift::protocol::TType _etype1338; + xfer += iprot->readListBegin(_etype1338, _size1335); + (*(this->success)).resize(_size1335); + uint32_t _i1339; + for (_i1339 = 0; _i1339 < _size1335; ++_i1339) { - xfer += iprot->readString((*(this->success))[_i1337]); + xfer += iprot->readString((*(this->success))[_i1339]); } xfer += iprot->readListEnd(); } @@ -31795,14 +32062,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1338; - ::apache::thrift::protocol::TType _etype1341; - xfer += iprot->readListBegin(_etype1341, _size1338); - this->success.resize(_size1338); - uint32_t _i1342; - for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + uint32_t _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->success.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->success[_i1342]); + xfer += iprot->readString(this->success[_i1344]); } xfer += iprot->readListEnd(); } @@ -31833,10 +32100,10 @@ uint32_t ThriftHiveMetastore_get_master_keys_result::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->success.size())); - std::vector ::const_iterator _iter1343; - for (_iter1343 = this->success.begin(); _iter1343 != this->success.end(); ++_iter1343) + std::vector ::const_iterator _iter1345; + for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1343)); + xfer += oprot->writeString((*_iter1345)); } xfer += oprot->writeListEnd(); } @@ -31877,14 +32144,14 @@ uint32_t ThriftHiveMetastore_get_master_keys_presult::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1344; - ::apache::thrift::protocol::TType _etype1347; - xfer += iprot->readListBegin(_etype1347, _size1344); - (*(this->success)).resize(_size1344); - uint32_t _i1348; - for (_i1348 = 0; _i1348 < _size1344; ++_i1348) + uint32_t _size1346; + ::apache::thrift::protocol::TType _etype1349; + xfer += iprot->readListBegin(_etype1349, _size1346); + (*(this->success)).resize(_size1346); + uint32_t _i1350; + for (_i1350 = 0; _i1350 < _size1346; ++_i1350) { - xfer += iprot->readString((*(this->success))[_i1348]); + xfer += iprot->readString((*(this->success))[_i1350]); } xfer += iprot->readListEnd(); } @@ -41819,6 +42086,76 @@ bool ThriftHiveMetastoreClient::recv_update_partition_column_statistics() throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "update_partition_column_statistics failed: unknown result"); } +bool ThriftHiveMetastoreClient::renew_column_statistics(const SetColumnStatsRequest& request) +{ + send_renew_column_statistics(request); + return recv_renew_column_statistics(); +} + +void ThriftHiveMetastoreClient::send_renew_column_statistics(const SetColumnStatsRequest& request) +{ + int32_t cseqid = 0; + oprot_->writeMessageBegin("renew_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_renew_column_statistics_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); +} + +bool ThriftHiveMetastoreClient::recv_renew_column_statistics() +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + iprot_->readMessageBegin(fname, mtype, rseqid); + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("renew_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + bool _return; + ThriftHiveMetastore_renew_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + return _return; + } + if (result.__isset.o1) { + throw result.o1; + } + if (result.__isset.o2) { + throw result.o2; + } + if (result.__isset.o3) { + throw result.o3; + } + if (result.__isset.o4) { + throw result.o4; + } + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_column_statistics failed: unknown result"); +} + void ThriftHiveMetastoreClient::get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) { send_get_table_column_statistics(db_name, tbl_name, col_name); @@ -50708,6 +51045,72 @@ void ThriftHiveMetastoreProcessor::process_update_partition_column_statistics(in } } +void ThriftHiveMetastoreProcessor::process_renew_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) +{ + void* ctx = NULL; + if (this->eventHandler_.get() != NULL) { + ctx = this->eventHandler_->getContext("ThriftHiveMetastore.renew_column_statistics", callContext); + } + ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ThriftHiveMetastore.renew_column_statistics"); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preRead(ctx, "ThriftHiveMetastore.renew_column_statistics"); + } + + ThriftHiveMetastore_renew_column_statistics_args args; + args.read(iprot); + iprot->readMessageEnd(); + uint32_t bytes = iprot->getTransport()->readEnd(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postRead(ctx, "ThriftHiveMetastore.renew_column_statistics", bytes); + } + + ThriftHiveMetastore_renew_column_statistics_result result; + try { + result.success = iface_->renew_column_statistics(args.request); + result.__isset.success = true; + } catch (NoSuchObjectException &o1) { + result.o1 = o1; + result.__isset.o1 = true; + } catch (InvalidObjectException &o2) { + result.o2 = o2; + result.__isset.o2 = true; + } catch (MetaException &o3) { + result.o3 = o3; + result.__isset.o3 = true; + } catch (InvalidInputException &o4) { + result.o4 = o4; + result.__isset.o4 = true; + } catch (const std::exception& e) { + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->handlerError(ctx, "ThriftHiveMetastore.renew_column_statistics"); + } + + ::apache::thrift::TApplicationException x(e.what()); + oprot->writeMessageBegin("renew_column_statistics", ::apache::thrift::protocol::T_EXCEPTION, seqid); + x.write(oprot); + oprot->writeMessageEnd(); + oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + return; + } + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->preWrite(ctx, "ThriftHiveMetastore.renew_column_statistics"); + } + + oprot->writeMessageBegin("renew_column_statistics", ::apache::thrift::protocol::T_REPLY, seqid); + result.write(oprot); + oprot->writeMessageEnd(); + bytes = oprot->getTransport()->writeEnd(); + oprot->getTransport()->flush(); + + if (this->eventHandler_.get() != NULL) { + this->eventHandler_->postWrite(ctx, "ThriftHiveMetastore.renew_column_statistics", bytes); + } +} + void ThriftHiveMetastoreProcessor::process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext) { void* ctx = NULL; @@ -62057,6 +62460,106 @@ bool ThriftHiveMetastoreConcurrentClient::recv_update_partition_column_statistic } // end while(true) } +bool ThriftHiveMetastoreConcurrentClient::renew_column_statistics(const SetColumnStatsRequest& request) +{ + int32_t seqid = send_renew_column_statistics(request); + return recv_renew_column_statistics(seqid); +} + +int32_t ThriftHiveMetastoreConcurrentClient::send_renew_column_statistics(const SetColumnStatsRequest& request) +{ + int32_t cseqid = this->sync_.generateSeqId(); + ::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_); + oprot_->writeMessageBegin("renew_column_statistics", ::apache::thrift::protocol::T_CALL, cseqid); + + ThriftHiveMetastore_renew_column_statistics_pargs args; + args.request = &request; + args.write(oprot_); + + oprot_->writeMessageEnd(); + oprot_->getTransport()->writeEnd(); + oprot_->getTransport()->flush(); + + sentry.commit(); + return cseqid; +} + +bool ThriftHiveMetastoreConcurrentClient::recv_renew_column_statistics(const int32_t seqid) +{ + + int32_t rseqid = 0; + std::string fname; + ::apache::thrift::protocol::TMessageType mtype; + + // the read mutex gets dropped and reacquired as part of waitForWork() + // The destructor of this sentry wakes up other clients + ::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid); + + while(true) { + if(!this->sync_.getPending(fname, mtype, rseqid)) { + iprot_->readMessageBegin(fname, mtype, rseqid); + } + if(seqid == rseqid) { + if (mtype == ::apache::thrift::protocol::T_EXCEPTION) { + ::apache::thrift::TApplicationException x; + x.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + sentry.commit(); + throw x; + } + if (mtype != ::apache::thrift::protocol::T_REPLY) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + } + if (fname.compare("renew_column_statistics") != 0) { + iprot_->skip(::apache::thrift::protocol::T_STRUCT); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + // in a bad state, don't commit + using ::apache::thrift::protocol::TProtocolException; + throw TProtocolException(TProtocolException::INVALID_DATA); + } + bool _return; + ThriftHiveMetastore_renew_column_statistics_presult result; + result.success = &_return; + result.read(iprot_); + iprot_->readMessageEnd(); + iprot_->getTransport()->readEnd(); + + if (result.__isset.success) { + sentry.commit(); + return _return; + } + if (result.__isset.o1) { + sentry.commit(); + throw result.o1; + } + if (result.__isset.o2) { + sentry.commit(); + throw result.o2; + } + if (result.__isset.o3) { + sentry.commit(); + throw result.o3; + } + if (result.__isset.o4) { + sentry.commit(); + throw result.o4; + } + // in a bad state, don't commit + throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "renew_column_statistics failed: unknown result"); + } + // seqid != rseqid + this->sync_.updatePending(fname, mtype, rseqid); + + // this will temporarily unlock the readMutex, and let other clients get work done + this->sync_.waitForWork(seqid); + } // end while(true) +} + void ThriftHiveMetastoreConcurrentClient::get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) { int32_t seqid = send_get_table_column_statistics(db_name, tbl_name, col_name); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h index 11d3322..70f4436 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -104,6 +104,7 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService virtual void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) = 0; virtual bool update_table_column_statistics(const ColumnStatistics& stats_obj) = 0; virtual bool update_partition_column_statistics(const ColumnStatistics& stats_obj) = 0; + virtual bool renew_column_statistics(const SetColumnStatsRequest& request) = 0; virtual void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0; virtual void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) = 0; virtual void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) = 0; @@ -457,6 +458,10 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p bool _return = false; return _return; } + bool renew_column_statistics(const SetColumnStatsRequest& /* request */) { + bool _return = false; + return _return; + } void get_table_column_statistics(ColumnStatistics& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* col_name */) { return; } @@ -11530,6 +11535,142 @@ class ThriftHiveMetastore_update_partition_column_statistics_presult { }; +typedef struct _ThriftHiveMetastore_renew_column_statistics_args__isset { + _ThriftHiveMetastore_renew_column_statistics_args__isset() : request(false) {} + bool request :1; +} _ThriftHiveMetastore_renew_column_statistics_args__isset; + +class ThriftHiveMetastore_renew_column_statistics_args { + public: + + ThriftHiveMetastore_renew_column_statistics_args(const ThriftHiveMetastore_renew_column_statistics_args&); + ThriftHiveMetastore_renew_column_statistics_args& operator=(const ThriftHiveMetastore_renew_column_statistics_args&); + ThriftHiveMetastore_renew_column_statistics_args() { + } + + virtual ~ThriftHiveMetastore_renew_column_statistics_args() throw(); + SetColumnStatsRequest request; + + _ThriftHiveMetastore_renew_column_statistics_args__isset __isset; + + void __set_request(const SetColumnStatsRequest& val); + + bool operator == (const ThriftHiveMetastore_renew_column_statistics_args & rhs) const + { + if (!(request == rhs.request)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_renew_column_statistics_args &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_renew_column_statistics_args & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + + +class ThriftHiveMetastore_renew_column_statistics_pargs { + public: + + + virtual ~ThriftHiveMetastore_renew_column_statistics_pargs() throw(); + const SetColumnStatsRequest* request; + + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_renew_column_statistics_result__isset { + _ThriftHiveMetastore_renew_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_renew_column_statistics_result__isset; + +class ThriftHiveMetastore_renew_column_statistics_result { + public: + + ThriftHiveMetastore_renew_column_statistics_result(const ThriftHiveMetastore_renew_column_statistics_result&); + ThriftHiveMetastore_renew_column_statistics_result& operator=(const ThriftHiveMetastore_renew_column_statistics_result&); + ThriftHiveMetastore_renew_column_statistics_result() : success(0) { + } + + virtual ~ThriftHiveMetastore_renew_column_statistics_result() throw(); + bool success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_renew_column_statistics_result__isset __isset; + + void __set_success(const bool val); + + void __set_o1(const NoSuchObjectException& val); + + void __set_o2(const InvalidObjectException& val); + + void __set_o3(const MetaException& val); + + void __set_o4(const InvalidInputException& val); + + bool operator == (const ThriftHiveMetastore_renew_column_statistics_result & rhs) const + { + if (!(success == rhs.success)) + return false; + if (!(o1 == rhs.o1)) + return false; + if (!(o2 == rhs.o2)) + return false; + if (!(o3 == rhs.o3)) + return false; + if (!(o4 == rhs.o4)) + return false; + return true; + } + bool operator != (const ThriftHiveMetastore_renew_column_statistics_result &rhs) const { + return !(*this == rhs); + } + + bool operator < (const ThriftHiveMetastore_renew_column_statistics_result & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + +}; + +typedef struct _ThriftHiveMetastore_renew_column_statistics_presult__isset { + _ThriftHiveMetastore_renew_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {} + bool success :1; + bool o1 :1; + bool o2 :1; + bool o3 :1; + bool o4 :1; +} _ThriftHiveMetastore_renew_column_statistics_presult__isset; + +class ThriftHiveMetastore_renew_column_statistics_presult { + public: + + + virtual ~ThriftHiveMetastore_renew_column_statistics_presult() throw(); + bool* success; + NoSuchObjectException o1; + InvalidObjectException o2; + MetaException o3; + InvalidInputException o4; + + _ThriftHiveMetastore_renew_column_statistics_presult__isset __isset; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + +}; + typedef struct _ThriftHiveMetastore_get_table_column_statistics_args__isset { _ThriftHiveMetastore_get_table_column_statistics_args__isset() : db_name(false), tbl_name(false), col_name(false) {} bool db_name :1; @@ -19040,6 +19181,9 @@ class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public bool update_partition_column_statistics(const ColumnStatistics& stats_obj); void send_update_partition_column_statistics(const ColumnStatistics& stats_obj); bool recv_update_partition_column_statistics(); + bool renew_column_statistics(const SetColumnStatsRequest& request); + void send_renew_column_statistics(const SetColumnStatsRequest& request); + bool recv_renew_column_statistics(); void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name); void send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); void recv_get_table_column_statistics(ColumnStatistics& _return); @@ -19324,6 +19468,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP void process_get_foreign_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_update_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_update_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); + void process_renew_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); void process_get_table_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); @@ -19474,6 +19619,7 @@ class ThriftHiveMetastoreProcessor : public ::facebook::fb303::FacebookServiceP processMap_["get_foreign_keys"] = &ThriftHiveMetastoreProcessor::process_get_foreign_keys; processMap_["update_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_table_column_statistics; processMap_["update_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_partition_column_statistics; + processMap_["renew_column_statistics"] = &ThriftHiveMetastoreProcessor::process_renew_column_statistics; processMap_["get_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_table_column_statistics; processMap_["get_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_partition_column_statistics; processMap_["get_table_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_table_statistics_req; @@ -20358,6 +20504,15 @@ class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, publi return ifaces_[i]->update_partition_column_statistics(stats_obj); } + bool renew_column_statistics(const SetColumnStatsRequest& request) { + size_t sz = ifaces_.size(); + size_t i = 0; + for (; i < (sz - 1); ++i) { + ifaces_[i]->renew_column_statistics(request); + } + return ifaces_[i]->renew_column_statistics(request); + } + void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) { size_t sz = ifaces_.size(); size_t i = 0; @@ -21234,6 +21389,9 @@ class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf bool update_partition_column_statistics(const ColumnStatistics& stats_obj); int32_t send_update_partition_column_statistics(const ColumnStatistics& stats_obj); bool recv_update_partition_column_statistics(const int32_t seqid); + bool renew_column_statistics(const SetColumnStatsRequest& request); + int32_t send_renew_column_statistics(const SetColumnStatsRequest& request); + bool recv_renew_column_statistics(const int32_t seqid); void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name); int32_t send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name); void recv_get_table_column_statistics(ColumnStatistics& _return, const int32_t seqid); diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp index fa87e34..24841a1 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp @@ -432,6 +432,11 @@ class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf { printf("update_partition_column_statistics\n"); } + bool renew_column_statistics(const SetColumnStatsRequest& request) { + // Your implementation goes here + printf("renew_column_statistics\n"); + } + void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) { // Your implementation goes here printf("get_table_column_statistics\n"); diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 8da883d..7fd867d 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -8165,6 +8165,11 @@ void SetPartitionsStatsRequest::__set_colStats(const std::vectorcolStats = val; } +void SetPartitionsStatsRequest::__set_numBitVector(const int32_t val) { + this->numBitVector = val; +__isset.numBitVector = true; +} + uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -8207,6 +8212,14 @@ uint32_t SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->numBitVector); + this->__isset.numBitVector = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -8238,6 +8251,11 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* } xfer += oprot->writeFieldEnd(); + if (this->__isset.numBitVector) { + xfer += oprot->writeFieldBegin("numBitVector", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->numBitVector); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -8246,19 +8264,137 @@ uint32_t SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* void swap(SetPartitionsStatsRequest &a, SetPartitionsStatsRequest &b) { using ::std::swap; swap(a.colStats, b.colStats); + swap(a.numBitVector, b.numBitVector); + swap(a.__isset, b.__isset); } SetPartitionsStatsRequest::SetPartitionsStatsRequest(const SetPartitionsStatsRequest& other329) { colStats = other329.colStats; + numBitVector = other329.numBitVector; + __isset = other329.__isset; } SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const SetPartitionsStatsRequest& other330) { colStats = other330.colStats; + numBitVector = other330.numBitVector; + __isset = other330.__isset; return *this; } void SetPartitionsStatsRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "SetPartitionsStatsRequest("; out << "colStats=" << to_string(colStats); + out << ", " << "numBitVector="; (__isset.numBitVector ? (out << to_string(numBitVector)) : (out << "")); + out << ")"; +} + + +SetColumnStatsRequest::~SetColumnStatsRequest() throw() { +} + + +void SetColumnStatsRequest::__set_colStats(const ColumnStatistics& val) { + this->colStats = val; +} + +void SetColumnStatsRequest::__set_numBitVector(const int32_t val) { + this->numBitVector = val; +__isset.numBitVector = true; +} + +uint32_t SetColumnStatsRequest::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; + + bool isset_colStats = false; + + 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->colStats.read(iprot); + isset_colStats = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_I32) { + xfer += iprot->readI32(this->numBitVector); + this->__isset.numBitVector = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + if (!isset_colStats) + throw TProtocolException(TProtocolException::INVALID_DATA); + return xfer; +} + +uint32_t SetColumnStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("SetColumnStatsRequest"); + + xfer += oprot->writeFieldBegin("colStats", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->colStats.write(oprot); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.numBitVector) { + xfer += oprot->writeFieldBegin("numBitVector", ::apache::thrift::protocol::T_I32, 2); + xfer += oprot->writeI32(this->numBitVector); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(SetColumnStatsRequest &a, SetColumnStatsRequest &b) { + using ::std::swap; + swap(a.colStats, b.colStats); + swap(a.numBitVector, b.numBitVector); + swap(a.__isset, b.__isset); +} + +SetColumnStatsRequest::SetColumnStatsRequest(const SetColumnStatsRequest& other331) { + colStats = other331.colStats; + numBitVector = other331.numBitVector; + __isset = other331.__isset; +} +SetColumnStatsRequest& SetColumnStatsRequest::operator=(const SetColumnStatsRequest& other332) { + colStats = other332.colStats; + numBitVector = other332.numBitVector; + __isset = other332.__isset; + return *this; +} +void SetColumnStatsRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "SetColumnStatsRequest("; + out << "colStats=" << to_string(colStats); + out << ", " << "numBitVector="; (__isset.numBitVector ? (out << to_string(numBitVector)) : (out << "")); out << ")"; } @@ -8300,14 +8436,14 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fieldSchemas.clear(); - uint32_t _size331; - ::apache::thrift::protocol::TType _etype334; - xfer += iprot->readListBegin(_etype334, _size331); - this->fieldSchemas.resize(_size331); - uint32_t _i335; - for (_i335 = 0; _i335 < _size331; ++_i335) + uint32_t _size333; + ::apache::thrift::protocol::TType _etype336; + xfer += iprot->readListBegin(_etype336, _size333); + this->fieldSchemas.resize(_size333); + uint32_t _i337; + for (_i337 = 0; _i337 < _size333; ++_i337) { - xfer += this->fieldSchemas[_i335].read(iprot); + xfer += this->fieldSchemas[_i337].read(iprot); } xfer += iprot->readListEnd(); } @@ -8320,17 +8456,17 @@ uint32_t Schema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size336; - ::apache::thrift::protocol::TType _ktype337; - ::apache::thrift::protocol::TType _vtype338; - xfer += iprot->readMapBegin(_ktype337, _vtype338, _size336); - uint32_t _i340; - for (_i340 = 0; _i340 < _size336; ++_i340) + uint32_t _size338; + ::apache::thrift::protocol::TType _ktype339; + ::apache::thrift::protocol::TType _vtype340; + xfer += iprot->readMapBegin(_ktype339, _vtype340, _size338); + uint32_t _i342; + for (_i342 = 0; _i342 < _size338; ++_i342) { - std::string _key341; - xfer += iprot->readString(_key341); - std::string& _val342 = this->properties[_key341]; - xfer += iprot->readString(_val342); + std::string _key343; + xfer += iprot->readString(_key343); + std::string& _val344 = this->properties[_key343]; + xfer += iprot->readString(_val344); } xfer += iprot->readMapEnd(); } @@ -8359,10 +8495,10 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("fieldSchemas", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->fieldSchemas.size())); - std::vector ::const_iterator _iter343; - for (_iter343 = this->fieldSchemas.begin(); _iter343 != this->fieldSchemas.end(); ++_iter343) + std::vector ::const_iterator _iter345; + for (_iter345 = this->fieldSchemas.begin(); _iter345 != this->fieldSchemas.end(); ++_iter345) { - xfer += (*_iter343).write(oprot); + xfer += (*_iter345).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8371,11 +8507,11 @@ uint32_t Schema::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter344; - for (_iter344 = this->properties.begin(); _iter344 != this->properties.end(); ++_iter344) + std::map ::const_iterator _iter346; + for (_iter346 = this->properties.begin(); _iter346 != this->properties.end(); ++_iter346) { - xfer += oprot->writeString(_iter344->first); - xfer += oprot->writeString(_iter344->second); + xfer += oprot->writeString(_iter346->first); + xfer += oprot->writeString(_iter346->second); } xfer += oprot->writeMapEnd(); } @@ -8393,15 +8529,15 @@ void swap(Schema &a, Schema &b) { swap(a.__isset, b.__isset); } -Schema::Schema(const Schema& other345) { - fieldSchemas = other345.fieldSchemas; - properties = other345.properties; - __isset = other345.__isset; +Schema::Schema(const Schema& other347) { + fieldSchemas = other347.fieldSchemas; + properties = other347.properties; + __isset = other347.__isset; } -Schema& Schema::operator=(const Schema& other346) { - fieldSchemas = other346.fieldSchemas; - properties = other346.properties; - __isset = other346.__isset; +Schema& Schema::operator=(const Schema& other348) { + fieldSchemas = other348.fieldSchemas; + properties = other348.properties; + __isset = other348.__isset; return *this; } void Schema::printTo(std::ostream& out) const { @@ -8446,17 +8582,17 @@ uint32_t EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size347; - ::apache::thrift::protocol::TType _ktype348; - ::apache::thrift::protocol::TType _vtype349; - xfer += iprot->readMapBegin(_ktype348, _vtype349, _size347); - uint32_t _i351; - for (_i351 = 0; _i351 < _size347; ++_i351) + uint32_t _size349; + ::apache::thrift::protocol::TType _ktype350; + ::apache::thrift::protocol::TType _vtype351; + xfer += iprot->readMapBegin(_ktype350, _vtype351, _size349); + uint32_t _i353; + for (_i353 = 0; _i353 < _size349; ++_i353) { - std::string _key352; - xfer += iprot->readString(_key352); - std::string& _val353 = this->properties[_key352]; - xfer += iprot->readString(_val353); + std::string _key354; + xfer += iprot->readString(_key354); + std::string& _val355 = this->properties[_key354]; + xfer += iprot->readString(_val355); } xfer += iprot->readMapEnd(); } @@ -8485,11 +8621,11 @@ uint32_t EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast(this->properties.size())); - std::map ::const_iterator _iter354; - for (_iter354 = this->properties.begin(); _iter354 != this->properties.end(); ++_iter354) + std::map ::const_iterator _iter356; + for (_iter356 = this->properties.begin(); _iter356 != this->properties.end(); ++_iter356) { - xfer += oprot->writeString(_iter354->first); - xfer += oprot->writeString(_iter354->second); + xfer += oprot->writeString(_iter356->first); + xfer += oprot->writeString(_iter356->second); } xfer += oprot->writeMapEnd(); } @@ -8506,13 +8642,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) { swap(a.__isset, b.__isset); } -EnvironmentContext::EnvironmentContext(const EnvironmentContext& other355) { - properties = other355.properties; - __isset = other355.__isset; +EnvironmentContext::EnvironmentContext(const EnvironmentContext& other357) { + properties = other357.properties; + __isset = other357.__isset; } -EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other356) { - properties = other356.properties; - __isset = other356.__isset; +EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& other358) { + properties = other358.properties; + __isset = other358.__isset; return *this; } void EnvironmentContext::printTo(std::ostream& out) const { @@ -8614,13 +8750,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) { swap(a.tbl_name, b.tbl_name); } -PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other357) { - db_name = other357.db_name; - tbl_name = other357.tbl_name; +PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other359) { + db_name = other359.db_name; + tbl_name = other359.tbl_name; } -PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other358) { - db_name = other358.db_name; - tbl_name = other358.tbl_name; +PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& other360) { + db_name = other360.db_name; + tbl_name = other360.tbl_name; return *this; } void PrimaryKeysRequest::printTo(std::ostream& out) const { @@ -8666,14 +8802,14 @@ uint32_t PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size359; - ::apache::thrift::protocol::TType _etype362; - xfer += iprot->readListBegin(_etype362, _size359); - this->primaryKeys.resize(_size359); - uint32_t _i363; - for (_i363 = 0; _i363 < _size359; ++_i363) + uint32_t _size361; + ::apache::thrift::protocol::TType _etype364; + xfer += iprot->readListBegin(_etype364, _size361); + this->primaryKeys.resize(_size361); + uint32_t _i365; + for (_i365 = 0; _i365 < _size361; ++_i365) { - xfer += this->primaryKeys[_i363].read(iprot); + xfer += this->primaryKeys[_i365].read(iprot); } xfer += iprot->readListEnd(); } @@ -8704,10 +8840,10 @@ uint32_t PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->primaryKeys.size())); - std::vector ::const_iterator _iter364; - for (_iter364 = this->primaryKeys.begin(); _iter364 != this->primaryKeys.end(); ++_iter364) + std::vector ::const_iterator _iter366; + for (_iter366 = this->primaryKeys.begin(); _iter366 != this->primaryKeys.end(); ++_iter366) { - xfer += (*_iter364).write(oprot); + xfer += (*_iter366).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8723,11 +8859,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse &b) { swap(a.primaryKeys, b.primaryKeys); } -PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other365) { - primaryKeys = other365.primaryKeys; +PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other367) { + primaryKeys = other367.primaryKeys; } -PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other366) { - primaryKeys = other366.primaryKeys; +PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& other368) { + primaryKeys = other368.primaryKeys; return *this; } void PrimaryKeysResponse::printTo(std::ostream& out) const { @@ -8869,17 +9005,17 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) { swap(a.foreign_tbl_name, b.foreign_tbl_name); } -ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other367) { - parent_db_name = other367.parent_db_name; - parent_tbl_name = other367.parent_tbl_name; - foreign_db_name = other367.foreign_db_name; - foreign_tbl_name = other367.foreign_tbl_name; +ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other369) { + parent_db_name = other369.parent_db_name; + parent_tbl_name = other369.parent_tbl_name; + foreign_db_name = other369.foreign_db_name; + foreign_tbl_name = other369.foreign_tbl_name; } -ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other368) { - parent_db_name = other368.parent_db_name; - parent_tbl_name = other368.parent_tbl_name; - foreign_db_name = other368.foreign_db_name; - foreign_tbl_name = other368.foreign_tbl_name; +ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& other370) { + parent_db_name = other370.parent_db_name; + parent_tbl_name = other370.parent_tbl_name; + foreign_db_name = other370.foreign_db_name; + foreign_tbl_name = other370.foreign_tbl_name; return *this; } void ForeignKeysRequest::printTo(std::ostream& out) const { @@ -8927,14 +9063,14 @@ uint32_t ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size369; - ::apache::thrift::protocol::TType _etype372; - xfer += iprot->readListBegin(_etype372, _size369); - this->foreignKeys.resize(_size369); - uint32_t _i373; - for (_i373 = 0; _i373 < _size369; ++_i373) + uint32_t _size371; + ::apache::thrift::protocol::TType _etype374; + xfer += iprot->readListBegin(_etype374, _size371); + this->foreignKeys.resize(_size371); + uint32_t _i375; + for (_i375 = 0; _i375 < _size371; ++_i375) { - xfer += this->foreignKeys[_i373].read(iprot); + xfer += this->foreignKeys[_i375].read(iprot); } xfer += iprot->readListEnd(); } @@ -8965,10 +9101,10 @@ uint32_t ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->foreignKeys.size())); - std::vector ::const_iterator _iter374; - for (_iter374 = this->foreignKeys.begin(); _iter374 != this->foreignKeys.end(); ++_iter374) + std::vector ::const_iterator _iter376; + for (_iter376 = this->foreignKeys.begin(); _iter376 != this->foreignKeys.end(); ++_iter376) { - xfer += (*_iter374).write(oprot); + xfer += (*_iter376).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8984,11 +9120,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse &b) { swap(a.foreignKeys, b.foreignKeys); } -ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other375) { - foreignKeys = other375.foreignKeys; +ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other377) { + foreignKeys = other377.foreignKeys; } -ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other376) { - foreignKeys = other376.foreignKeys; +ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& other378) { + foreignKeys = other378.foreignKeys; return *this; } void ForeignKeysResponse::printTo(std::ostream& out) const { @@ -9038,14 +9174,14 @@ uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size377; - ::apache::thrift::protocol::TType _etype380; - xfer += iprot->readListBegin(_etype380, _size377); - this->partitions.resize(_size377); - uint32_t _i381; - for (_i381 = 0; _i381 < _size377; ++_i381) + uint32_t _size379; + ::apache::thrift::protocol::TType _etype382; + xfer += iprot->readListBegin(_etype382, _size379); + this->partitions.resize(_size379); + uint32_t _i383; + for (_i383 = 0; _i383 < _size379; ++_i383) { - xfer += this->partitions[_i381].read(iprot); + xfer += this->partitions[_i383].read(iprot); } xfer += iprot->readListEnd(); } @@ -9086,10 +9222,10 @@ uint32_t PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter382; - for (_iter382 = this->partitions.begin(); _iter382 != this->partitions.end(); ++_iter382) + std::vector ::const_iterator _iter384; + for (_iter384 = this->partitions.begin(); _iter384 != this->partitions.end(); ++_iter384) { - xfer += (*_iter382).write(oprot); + xfer += (*_iter384).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9110,13 +9246,13 @@ void swap(PartitionsByExprResult &a, PartitionsByExprResult &b) { swap(a.hasUnknownPartitions, b.hasUnknownPartitions); } -PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other383) { - partitions = other383.partitions; - hasUnknownPartitions = other383.hasUnknownPartitions; +PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& other385) { + partitions = other385.partitions; + hasUnknownPartitions = other385.hasUnknownPartitions; } -PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other384) { - partitions = other384.partitions; - hasUnknownPartitions = other384.hasUnknownPartitions; +PartitionsByExprResult& PartitionsByExprResult::operator=(const PartitionsByExprResult& other386) { + partitions = other386.partitions; + hasUnknownPartitions = other386.hasUnknownPartitions; return *this; } void PartitionsByExprResult::printTo(std::ostream& out) const { @@ -9278,21 +9414,21 @@ void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b) { swap(a.__isset, b.__isset); } -PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other385) { - dbName = other385.dbName; - tblName = other385.tblName; - expr = other385.expr; - defaultPartitionName = other385.defaultPartitionName; - maxParts = other385.maxParts; - __isset = other385.__isset; -} -PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other386) { - dbName = other386.dbName; - tblName = other386.tblName; - expr = other386.expr; - defaultPartitionName = other386.defaultPartitionName; - maxParts = other386.maxParts; - __isset = other386.__isset; +PartitionsByExprRequest::PartitionsByExprRequest(const PartitionsByExprRequest& other387) { + dbName = other387.dbName; + tblName = other387.tblName; + expr = other387.expr; + defaultPartitionName = other387.defaultPartitionName; + maxParts = other387.maxParts; + __isset = other387.__isset; +} +PartitionsByExprRequest& PartitionsByExprRequest::operator=(const PartitionsByExprRequest& other388) { + dbName = other388.dbName; + tblName = other388.tblName; + expr = other388.expr; + defaultPartitionName = other388.defaultPartitionName; + maxParts = other388.maxParts; + __isset = other388.__isset; return *this; } void PartitionsByExprRequest::printTo(std::ostream& out) const { @@ -9341,14 +9477,14 @@ uint32_t TableStatsResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tableStats.clear(); - uint32_t _size387; - ::apache::thrift::protocol::TType _etype390; - xfer += iprot->readListBegin(_etype390, _size387); - this->tableStats.resize(_size387); - uint32_t _i391; - for (_i391 = 0; _i391 < _size387; ++_i391) + uint32_t _size389; + ::apache::thrift::protocol::TType _etype392; + xfer += iprot->readListBegin(_etype392, _size389); + this->tableStats.resize(_size389); + uint32_t _i393; + for (_i393 = 0; _i393 < _size389; ++_i393) { - xfer += this->tableStats[_i391].read(iprot); + xfer += this->tableStats[_i393].read(iprot); } xfer += iprot->readListEnd(); } @@ -9379,10 +9515,10 @@ uint32_t TableStatsResult::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("tableStats", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->tableStats.size())); - std::vector ::const_iterator _iter392; - for (_iter392 = this->tableStats.begin(); _iter392 != this->tableStats.end(); ++_iter392) + std::vector ::const_iterator _iter394; + for (_iter394 = this->tableStats.begin(); _iter394 != this->tableStats.end(); ++_iter394) { - xfer += (*_iter392).write(oprot); + xfer += (*_iter394).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9398,11 +9534,11 @@ void swap(TableStatsResult &a, TableStatsResult &b) { swap(a.tableStats, b.tableStats); } -TableStatsResult::TableStatsResult(const TableStatsResult& other393) { - tableStats = other393.tableStats; +TableStatsResult::TableStatsResult(const TableStatsResult& other395) { + tableStats = other395.tableStats; } -TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other394) { - tableStats = other394.tableStats; +TableStatsResult& TableStatsResult::operator=(const TableStatsResult& other396) { + tableStats = other396.tableStats; return *this; } void TableStatsResult::printTo(std::ostream& out) const { @@ -9447,26 +9583,26 @@ uint32_t PartitionsStatsResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partStats.clear(); - uint32_t _size395; - ::apache::thrift::protocol::TType _ktype396; - ::apache::thrift::protocol::TType _vtype397; - xfer += iprot->readMapBegin(_ktype396, _vtype397, _size395); - uint32_t _i399; - for (_i399 = 0; _i399 < _size395; ++_i399) + uint32_t _size397; + ::apache::thrift::protocol::TType _ktype398; + ::apache::thrift::protocol::TType _vtype399; + xfer += iprot->readMapBegin(_ktype398, _vtype399, _size397); + uint32_t _i401; + for (_i401 = 0; _i401 < _size397; ++_i401) { - std::string _key400; - xfer += iprot->readString(_key400); - std::vector & _val401 = this->partStats[_key400]; + std::string _key402; + xfer += iprot->readString(_key402); + std::vector & _val403 = this->partStats[_key402]; { - _val401.clear(); - uint32_t _size402; - ::apache::thrift::protocol::TType _etype405; - xfer += iprot->readListBegin(_etype405, _size402); - _val401.resize(_size402); - uint32_t _i406; - for (_i406 = 0; _i406 < _size402; ++_i406) + _val403.clear(); + uint32_t _size404; + ::apache::thrift::protocol::TType _etype407; + xfer += iprot->readListBegin(_etype407, _size404); + _val403.resize(_size404); + uint32_t _i408; + for (_i408 = 0; _i408 < _size404; ++_i408) { - xfer += _val401[_i406].read(iprot); + xfer += _val403[_i408].read(iprot); } xfer += iprot->readListEnd(); } @@ -9500,16 +9636,16 @@ uint32_t PartitionsStatsResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("partStats", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast(this->partStats.size())); - std::map > ::const_iterator _iter407; - for (_iter407 = this->partStats.begin(); _iter407 != this->partStats.end(); ++_iter407) + std::map > ::const_iterator _iter409; + for (_iter409 = this->partStats.begin(); _iter409 != this->partStats.end(); ++_iter409) { - xfer += oprot->writeString(_iter407->first); + xfer += oprot->writeString(_iter409->first); { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter407->second.size())); - std::vector ::const_iterator _iter408; - for (_iter408 = _iter407->second.begin(); _iter408 != _iter407->second.end(); ++_iter408) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(_iter409->second.size())); + std::vector ::const_iterator _iter410; + for (_iter410 = _iter409->second.begin(); _iter410 != _iter409->second.end(); ++_iter410) { - xfer += (*_iter408).write(oprot); + xfer += (*_iter410).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9528,11 +9664,11 @@ void swap(PartitionsStatsResult &a, PartitionsStatsResult &b) { swap(a.partStats, b.partStats); } -PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other409) { - partStats = other409.partStats; +PartitionsStatsResult::PartitionsStatsResult(const PartitionsStatsResult& other411) { + partStats = other411.partStats; } -PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other410) { - partStats = other410.partStats; +PartitionsStatsResult& PartitionsStatsResult::operator=(const PartitionsStatsResult& other412) { + partStats = other412.partStats; return *this; } void PartitionsStatsResult::printTo(std::ostream& out) const { @@ -9603,14 +9739,14 @@ uint32_t TableStatsRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size411; - ::apache::thrift::protocol::TType _etype414; - xfer += iprot->readListBegin(_etype414, _size411); - this->colNames.resize(_size411); - uint32_t _i415; - for (_i415 = 0; _i415 < _size411; ++_i415) + uint32_t _size413; + ::apache::thrift::protocol::TType _etype416; + xfer += iprot->readListBegin(_etype416, _size413); + this->colNames.resize(_size413); + uint32_t _i417; + for (_i417 = 0; _i417 < _size413; ++_i417) { - xfer += iprot->readString(this->colNames[_i415]); + xfer += iprot->readString(this->colNames[_i417]); } xfer += iprot->readListEnd(); } @@ -9653,10 +9789,10 @@ uint32_t TableStatsRequest::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter416; - for (_iter416 = this->colNames.begin(); _iter416 != this->colNames.end(); ++_iter416) + std::vector ::const_iterator _iter418; + for (_iter418 = this->colNames.begin(); _iter418 != this->colNames.end(); ++_iter418) { - xfer += oprot->writeString((*_iter416)); + xfer += oprot->writeString((*_iter418)); } xfer += oprot->writeListEnd(); } @@ -9674,15 +9810,15 @@ void swap(TableStatsRequest &a, TableStatsRequest &b) { swap(a.colNames, b.colNames); } -TableStatsRequest::TableStatsRequest(const TableStatsRequest& other417) { - dbName = other417.dbName; - tblName = other417.tblName; - colNames = other417.colNames; +TableStatsRequest::TableStatsRequest(const TableStatsRequest& other419) { + dbName = other419.dbName; + tblName = other419.tblName; + colNames = other419.colNames; } -TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other418) { - dbName = other418.dbName; - tblName = other418.tblName; - colNames = other418.colNames; +TableStatsRequest& TableStatsRequest::operator=(const TableStatsRequest& other420) { + dbName = other420.dbName; + tblName = other420.tblName; + colNames = other420.colNames; return *this; } void TableStatsRequest::printTo(std::ostream& out) const { @@ -9760,14 +9896,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colNames.clear(); - uint32_t _size419; - ::apache::thrift::protocol::TType _etype422; - xfer += iprot->readListBegin(_etype422, _size419); - this->colNames.resize(_size419); - uint32_t _i423; - for (_i423 = 0; _i423 < _size419; ++_i423) + uint32_t _size421; + ::apache::thrift::protocol::TType _etype424; + xfer += iprot->readListBegin(_etype424, _size421); + this->colNames.resize(_size421); + uint32_t _i425; + for (_i425 = 0; _i425 < _size421; ++_i425) { - xfer += iprot->readString(this->colNames[_i423]); + xfer += iprot->readString(this->colNames[_i425]); } xfer += iprot->readListEnd(); } @@ -9780,14 +9916,14 @@ uint32_t PartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size424; - ::apache::thrift::protocol::TType _etype427; - xfer += iprot->readListBegin(_etype427, _size424); - this->partNames.resize(_size424); - uint32_t _i428; - for (_i428 = 0; _i428 < _size424; ++_i428) + uint32_t _size426; + ::apache::thrift::protocol::TType _etype429; + xfer += iprot->readListBegin(_etype429, _size426); + this->partNames.resize(_size426); + uint32_t _i430; + for (_i430 = 0; _i430 < _size426; ++_i430) { - xfer += iprot->readString(this->partNames[_i428]); + xfer += iprot->readString(this->partNames[_i430]); } xfer += iprot->readListEnd(); } @@ -9832,10 +9968,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("colNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->colNames.size())); - std::vector ::const_iterator _iter429; - for (_iter429 = this->colNames.begin(); _iter429 != this->colNames.end(); ++_iter429) + std::vector ::const_iterator _iter431; + for (_iter431 = this->colNames.begin(); _iter431 != this->colNames.end(); ++_iter431) { - xfer += oprot->writeString((*_iter429)); + xfer += oprot->writeString((*_iter431)); } xfer += oprot->writeListEnd(); } @@ -9844,10 +9980,10 @@ uint32_t PartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partNames.size())); - std::vector ::const_iterator _iter430; - for (_iter430 = this->partNames.begin(); _iter430 != this->partNames.end(); ++_iter430) + std::vector ::const_iterator _iter432; + for (_iter432 = this->partNames.begin(); _iter432 != this->partNames.end(); ++_iter432) { - xfer += oprot->writeString((*_iter430)); + xfer += oprot->writeString((*_iter432)); } xfer += oprot->writeListEnd(); } @@ -9866,17 +10002,17 @@ void swap(PartitionsStatsRequest &a, PartitionsStatsRequest &b) { swap(a.partNames, b.partNames); } -PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other431) { - dbName = other431.dbName; - tblName = other431.tblName; - colNames = other431.colNames; - partNames = other431.partNames; +PartitionsStatsRequest::PartitionsStatsRequest(const PartitionsStatsRequest& other433) { + dbName = other433.dbName; + tblName = other433.tblName; + colNames = other433.colNames; + partNames = other433.partNames; } -PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other432) { - dbName = other432.dbName; - tblName = other432.tblName; - colNames = other432.colNames; - partNames = other432.partNames; +PartitionsStatsRequest& PartitionsStatsRequest::operator=(const PartitionsStatsRequest& other434) { + dbName = other434.dbName; + tblName = other434.tblName; + colNames = other434.colNames; + partNames = other434.partNames; return *this; } void PartitionsStatsRequest::printTo(std::ostream& out) const { @@ -9924,14 +10060,14 @@ uint32_t AddPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size433; - ::apache::thrift::protocol::TType _etype436; - xfer += iprot->readListBegin(_etype436, _size433); - this->partitions.resize(_size433); - uint32_t _i437; - for (_i437 = 0; _i437 < _size433; ++_i437) + uint32_t _size435; + ::apache::thrift::protocol::TType _etype438; + xfer += iprot->readListBegin(_etype438, _size435); + this->partitions.resize(_size435); + uint32_t _i439; + for (_i439 = 0; _i439 < _size435; ++_i439) { - xfer += this->partitions[_i437].read(iprot); + xfer += this->partitions[_i439].read(iprot); } xfer += iprot->readListEnd(); } @@ -9961,10 +10097,10 @@ uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter438; - for (_iter438 = this->partitions.begin(); _iter438 != this->partitions.end(); ++_iter438) + std::vector ::const_iterator _iter440; + for (_iter440 = this->partitions.begin(); _iter440 != this->partitions.end(); ++_iter440) { - xfer += (*_iter438).write(oprot); + xfer += (*_iter440).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9981,13 +10117,13 @@ void swap(AddPartitionsResult &a, AddPartitionsResult &b) { swap(a.__isset, b.__isset); } -AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other439) { - partitions = other439.partitions; - __isset = other439.__isset; +AddPartitionsResult::AddPartitionsResult(const AddPartitionsResult& other441) { + partitions = other441.partitions; + __isset = other441.__isset; } -AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other440) { - partitions = other440.partitions; - __isset = other440.__isset; +AddPartitionsResult& AddPartitionsResult::operator=(const AddPartitionsResult& other442) { + partitions = other442.partitions; + __isset = other442.__isset; return *this; } void AddPartitionsResult::printTo(std::ostream& out) const { @@ -10068,14 +10204,14 @@ uint32_t AddPartitionsRequest::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->parts.clear(); - uint32_t _size441; - ::apache::thrift::protocol::TType _etype444; - xfer += iprot->readListBegin(_etype444, _size441); - this->parts.resize(_size441); - uint32_t _i445; - for (_i445 = 0; _i445 < _size441; ++_i445) + uint32_t _size443; + ::apache::thrift::protocol::TType _etype446; + xfer += iprot->readListBegin(_etype446, _size443); + this->parts.resize(_size443); + uint32_t _i447; + for (_i447 = 0; _i447 < _size443; ++_i447) { - xfer += this->parts[_i445].read(iprot); + xfer += this->parts[_i447].read(iprot); } xfer += iprot->readListEnd(); } @@ -10136,10 +10272,10 @@ uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->parts.size())); - std::vector ::const_iterator _iter446; - for (_iter446 = this->parts.begin(); _iter446 != this->parts.end(); ++_iter446) + std::vector ::const_iterator _iter448; + for (_iter448 = this->parts.begin(); _iter448 != this->parts.end(); ++_iter448) { - xfer += (*_iter446).write(oprot); + xfer += (*_iter448).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10169,21 +10305,21 @@ void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) { swap(a.__isset, b.__isset); } -AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other447) { - dbName = other447.dbName; - tblName = other447.tblName; - parts = other447.parts; - ifNotExists = other447.ifNotExists; - needResult = other447.needResult; - __isset = other447.__isset; -} -AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other448) { - dbName = other448.dbName; - tblName = other448.tblName; - parts = other448.parts; - ifNotExists = other448.ifNotExists; - needResult = other448.needResult; - __isset = other448.__isset; +AddPartitionsRequest::AddPartitionsRequest(const AddPartitionsRequest& other449) { + dbName = other449.dbName; + tblName = other449.tblName; + parts = other449.parts; + ifNotExists = other449.ifNotExists; + needResult = other449.needResult; + __isset = other449.__isset; +} +AddPartitionsRequest& AddPartitionsRequest::operator=(const AddPartitionsRequest& other450) { + dbName = other450.dbName; + tblName = other450.tblName; + parts = other450.parts; + ifNotExists = other450.ifNotExists; + needResult = other450.needResult; + __isset = other450.__isset; return *this; } void AddPartitionsRequest::printTo(std::ostream& out) const { @@ -10232,14 +10368,14 @@ uint32_t DropPartitionsResult::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitions.clear(); - uint32_t _size449; - ::apache::thrift::protocol::TType _etype452; - xfer += iprot->readListBegin(_etype452, _size449); - this->partitions.resize(_size449); - uint32_t _i453; - for (_i453 = 0; _i453 < _size449; ++_i453) + uint32_t _size451; + ::apache::thrift::protocol::TType _etype454; + xfer += iprot->readListBegin(_etype454, _size451); + this->partitions.resize(_size451); + uint32_t _i455; + for (_i455 = 0; _i455 < _size451; ++_i455) { - xfer += this->partitions[_i453].read(iprot); + xfer += this->partitions[_i455].read(iprot); } xfer += iprot->readListEnd(); } @@ -10269,10 +10405,10 @@ uint32_t DropPartitionsResult::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->partitions.size())); - std::vector ::const_iterator _iter454; - for (_iter454 = this->partitions.begin(); _iter454 != this->partitions.end(); ++_iter454) + std::vector ::const_iterator _iter456; + for (_iter456 = this->partitions.begin(); _iter456 != this->partitions.end(); ++_iter456) { - xfer += (*_iter454).write(oprot); + xfer += (*_iter456).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10289,13 +10425,13 @@ void swap(DropPartitionsResult &a, DropPartitionsResult &b) { swap(a.__isset, b.__isset); } -DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other455) { - partitions = other455.partitions; - __isset = other455.__isset; +DropPartitionsResult::DropPartitionsResult(const DropPartitionsResult& other457) { + partitions = other457.partitions; + __isset = other457.__isset; } -DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other456) { - partitions = other456.partitions; - __isset = other456.__isset; +DropPartitionsResult& DropPartitionsResult::operator=(const DropPartitionsResult& other458) { + partitions = other458.partitions; + __isset = other458.__isset; return *this; } void DropPartitionsResult::printTo(std::ostream& out) const { @@ -10397,15 +10533,15 @@ void swap(DropPartitionsExpr &a, DropPartitionsExpr &b) { swap(a.__isset, b.__isset); } -DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other457) { - expr = other457.expr; - partArchiveLevel = other457.partArchiveLevel; - __isset = other457.__isset; +DropPartitionsExpr::DropPartitionsExpr(const DropPartitionsExpr& other459) { + expr = other459.expr; + partArchiveLevel = other459.partArchiveLevel; + __isset = other459.__isset; } -DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other458) { - expr = other458.expr; - partArchiveLevel = other458.partArchiveLevel; - __isset = other458.__isset; +DropPartitionsExpr& DropPartitionsExpr::operator=(const DropPartitionsExpr& other460) { + expr = other460.expr; + partArchiveLevel = other460.partArchiveLevel; + __isset = other460.__isset; return *this; } void DropPartitionsExpr::printTo(std::ostream& out) const { @@ -10454,14 +10590,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->names.clear(); - uint32_t _size459; - ::apache::thrift::protocol::TType _etype462; - xfer += iprot->readListBegin(_etype462, _size459); - this->names.resize(_size459); - uint32_t _i463; - for (_i463 = 0; _i463 < _size459; ++_i463) + uint32_t _size461; + ::apache::thrift::protocol::TType _etype464; + xfer += iprot->readListBegin(_etype464, _size461); + this->names.resize(_size461); + uint32_t _i465; + for (_i465 = 0; _i465 < _size461; ++_i465) { - xfer += iprot->readString(this->names[_i463]); + xfer += iprot->readString(this->names[_i465]); } xfer += iprot->readListEnd(); } @@ -10474,14 +10610,14 @@ uint32_t RequestPartsSpec::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->exprs.clear(); - uint32_t _size464; - ::apache::thrift::protocol::TType _etype467; - xfer += iprot->readListBegin(_etype467, _size464); - this->exprs.resize(_size464); - uint32_t _i468; - for (_i468 = 0; _i468 < _size464; ++_i468) + uint32_t _size466; + ::apache::thrift::protocol::TType _etype469; + xfer += iprot->readListBegin(_etype469, _size466); + this->exprs.resize(_size466); + uint32_t _i470; + for (_i470 = 0; _i470 < _size466; ++_i470) { - xfer += this->exprs[_i468].read(iprot); + xfer += this->exprs[_i470].read(iprot); } xfer += iprot->readListEnd(); } @@ -10510,10 +10646,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->names.size())); - std::vector ::const_iterator _iter469; - for (_iter469 = this->names.begin(); _iter469 != this->names.end(); ++_iter469) + std::vector ::const_iterator _iter471; + for (_iter471 = this->names.begin(); _iter471 != this->names.end(); ++_iter471) { - xfer += oprot->writeString((*_iter469)); + xfer += oprot->writeString((*_iter471)); } xfer += oprot->writeListEnd(); } @@ -10522,10 +10658,10 @@ uint32_t RequestPartsSpec::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("exprs", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->exprs.size())); - std::vector ::const_iterator _iter470; - for (_iter470 = this->exprs.begin(); _iter470 != this->exprs.end(); ++_iter470) + std::vector ::const_iterator _iter472; + for (_iter472 = this->exprs.begin(); _iter472 != this->exprs.end(); ++_iter472) { - xfer += (*_iter470).write(oprot); + xfer += (*_iter472).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10543,15 +10679,15 @@ void swap(RequestPartsSpec &a, RequestPartsSpec &b) { swap(a.__isset, b.__isset); } -RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other471) { - names = other471.names; - exprs = other471.exprs; - __isset = other471.__isset; +RequestPartsSpec::RequestPartsSpec(const RequestPartsSpec& other473) { + names = other473.names; + exprs = other473.exprs; + __isset = other473.__isset; } -RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other472) { - names = other472.names; - exprs = other472.exprs; - __isset = other472.__isset; +RequestPartsSpec& RequestPartsSpec::operator=(const RequestPartsSpec& other474) { + names = other474.names; + exprs = other474.exprs; + __isset = other474.__isset; return *this; } void RequestPartsSpec::printTo(std::ostream& out) const { @@ -10770,27 +10906,27 @@ void swap(DropPartitionsRequest &a, DropPartitionsRequest &b) { swap(a.__isset, b.__isset); } -DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other473) { - dbName = other473.dbName; - tblName = other473.tblName; - parts = other473.parts; - deleteData = other473.deleteData; - ifExists = other473.ifExists; - ignoreProtection = other473.ignoreProtection; - environmentContext = other473.environmentContext; - needResult = other473.needResult; - __isset = other473.__isset; -} -DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other474) { - dbName = other474.dbName; - tblName = other474.tblName; - parts = other474.parts; - deleteData = other474.deleteData; - ifExists = other474.ifExists; - ignoreProtection = other474.ignoreProtection; - environmentContext = other474.environmentContext; - needResult = other474.needResult; - __isset = other474.__isset; +DropPartitionsRequest::DropPartitionsRequest(const DropPartitionsRequest& other475) { + dbName = other475.dbName; + tblName = other475.tblName; + parts = other475.parts; + deleteData = other475.deleteData; + ifExists = other475.ifExists; + ignoreProtection = other475.ignoreProtection; + environmentContext = other475.environmentContext; + needResult = other475.needResult; + __isset = other475.__isset; +} +DropPartitionsRequest& DropPartitionsRequest::operator=(const DropPartitionsRequest& other476) { + dbName = other476.dbName; + tblName = other476.tblName; + parts = other476.parts; + deleteData = other476.deleteData; + ifExists = other476.ifExists; + ignoreProtection = other476.ignoreProtection; + environmentContext = other476.environmentContext; + needResult = other476.needResult; + __isset = other476.__isset; return *this; } void DropPartitionsRequest::printTo(std::ostream& out) const { @@ -10843,9 +10979,9 @@ uint32_t ResourceUri::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast475; - xfer += iprot->readI32(ecast475); - this->resourceType = (ResourceType::type)ecast475; + int32_t ecast477; + xfer += iprot->readI32(ecast477); + this->resourceType = (ResourceType::type)ecast477; this->__isset.resourceType = true; } else { xfer += iprot->skip(ftype); @@ -10896,15 +11032,15 @@ void swap(ResourceUri &a, ResourceUri &b) { swap(a.__isset, b.__isset); } -ResourceUri::ResourceUri(const ResourceUri& other476) { - resourceType = other476.resourceType; - uri = other476.uri; - __isset = other476.__isset; +ResourceUri::ResourceUri(const ResourceUri& other478) { + resourceType = other478.resourceType; + uri = other478.uri; + __isset = other478.__isset; } -ResourceUri& ResourceUri::operator=(const ResourceUri& other477) { - resourceType = other477.resourceType; - uri = other477.uri; - __isset = other477.__isset; +ResourceUri& ResourceUri::operator=(const ResourceUri& other479) { + resourceType = other479.resourceType; + uri = other479.uri; + __isset = other479.__isset; return *this; } void ResourceUri::printTo(std::ostream& out) const { @@ -11007,9 +11143,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast478; - xfer += iprot->readI32(ecast478); - this->ownerType = (PrincipalType::type)ecast478; + int32_t ecast480; + xfer += iprot->readI32(ecast480); + this->ownerType = (PrincipalType::type)ecast480; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); @@ -11025,9 +11161,9 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast479; - xfer += iprot->readI32(ecast479); - this->functionType = (FunctionType::type)ecast479; + int32_t ecast481; + xfer += iprot->readI32(ecast481); + this->functionType = (FunctionType::type)ecast481; this->__isset.functionType = true; } else { xfer += iprot->skip(ftype); @@ -11037,14 +11173,14 @@ uint32_t Function::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->resourceUris.clear(); - uint32_t _size480; - ::apache::thrift::protocol::TType _etype483; - xfer += iprot->readListBegin(_etype483, _size480); - this->resourceUris.resize(_size480); - uint32_t _i484; - for (_i484 = 0; _i484 < _size480; ++_i484) + uint32_t _size482; + ::apache::thrift::protocol::TType _etype485; + xfer += iprot->readListBegin(_etype485, _size482); + this->resourceUris.resize(_size482); + uint32_t _i486; + for (_i486 = 0; _i486 < _size482; ++_i486) { - xfer += this->resourceUris[_i484].read(iprot); + xfer += this->resourceUris[_i486].read(iprot); } xfer += iprot->readListEnd(); } @@ -11101,10 +11237,10 @@ uint32_t Function::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("resourceUris", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->resourceUris.size())); - std::vector ::const_iterator _iter485; - for (_iter485 = this->resourceUris.begin(); _iter485 != this->resourceUris.end(); ++_iter485) + std::vector ::const_iterator _iter487; + for (_iter487 = this->resourceUris.begin(); _iter487 != this->resourceUris.end(); ++_iter487) { - xfer += (*_iter485).write(oprot); + xfer += (*_iter487).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11128,27 +11264,27 @@ void swap(Function &a, Function &b) { swap(a.__isset, b.__isset); } -Function::Function(const Function& other486) { - functionName = other486.functionName; - dbName = other486.dbName; - className = other486.className; - ownerName = other486.ownerName; - ownerType = other486.ownerType; - createTime = other486.createTime; - functionType = other486.functionType; - resourceUris = other486.resourceUris; - __isset = other486.__isset; -} -Function& Function::operator=(const Function& other487) { - functionName = other487.functionName; - dbName = other487.dbName; - className = other487.className; - ownerName = other487.ownerName; - ownerType = other487.ownerType; - createTime = other487.createTime; - functionType = other487.functionType; - resourceUris = other487.resourceUris; - __isset = other487.__isset; +Function::Function(const Function& other488) { + functionName = other488.functionName; + dbName = other488.dbName; + className = other488.className; + ownerName = other488.ownerName; + ownerType = other488.ownerType; + createTime = other488.createTime; + functionType = other488.functionType; + resourceUris = other488.resourceUris; + __isset = other488.__isset; +} +Function& Function::operator=(const Function& other489) { + functionName = other489.functionName; + dbName = other489.dbName; + className = other489.className; + ownerName = other489.ownerName; + ownerType = other489.ownerType; + createTime = other489.createTime; + functionType = other489.functionType; + resourceUris = other489.resourceUris; + __isset = other489.__isset; return *this; } void Function::printTo(std::ostream& out) const { @@ -11236,9 +11372,9 @@ uint32_t TxnInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast488; - xfer += iprot->readI32(ecast488); - this->state = (TxnState::type)ecast488; + int32_t ecast490; + xfer += iprot->readI32(ecast490); + this->state = (TxnState::type)ecast490; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -11357,25 +11493,25 @@ void swap(TxnInfo &a, TxnInfo &b) { swap(a.__isset, b.__isset); } -TxnInfo::TxnInfo(const TxnInfo& other489) { - id = other489.id; - state = other489.state; - user = other489.user; - hostname = other489.hostname; - agentInfo = other489.agentInfo; - heartbeatCount = other489.heartbeatCount; - metaInfo = other489.metaInfo; - __isset = other489.__isset; -} -TxnInfo& TxnInfo::operator=(const TxnInfo& other490) { - id = other490.id; - state = other490.state; - user = other490.user; - hostname = other490.hostname; - agentInfo = other490.agentInfo; - heartbeatCount = other490.heartbeatCount; - metaInfo = other490.metaInfo; - __isset = other490.__isset; +TxnInfo::TxnInfo(const TxnInfo& other491) { + id = other491.id; + state = other491.state; + user = other491.user; + hostname = other491.hostname; + agentInfo = other491.agentInfo; + heartbeatCount = other491.heartbeatCount; + metaInfo = other491.metaInfo; + __isset = other491.__isset; +} +TxnInfo& TxnInfo::operator=(const TxnInfo& other492) { + id = other492.id; + state = other492.state; + user = other492.user; + hostname = other492.hostname; + agentInfo = other492.agentInfo; + heartbeatCount = other492.heartbeatCount; + metaInfo = other492.metaInfo; + __isset = other492.__isset; return *this; } void TxnInfo::printTo(std::ostream& out) const { @@ -11439,14 +11575,14 @@ uint32_t GetOpenTxnsInfoResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->open_txns.clear(); - uint32_t _size491; - ::apache::thrift::protocol::TType _etype494; - xfer += iprot->readListBegin(_etype494, _size491); - this->open_txns.resize(_size491); - uint32_t _i495; - for (_i495 = 0; _i495 < _size491; ++_i495) + uint32_t _size493; + ::apache::thrift::protocol::TType _etype496; + xfer += iprot->readListBegin(_etype496, _size493); + this->open_txns.resize(_size493); + uint32_t _i497; + for (_i497 = 0; _i497 < _size493; ++_i497) { - xfer += this->open_txns[_i495].read(iprot); + xfer += this->open_txns[_i497].read(iprot); } xfer += iprot->readListEnd(); } @@ -11483,10 +11619,10 @@ uint32_t GetOpenTxnsInfoResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->open_txns.size())); - std::vector ::const_iterator _iter496; - for (_iter496 = this->open_txns.begin(); _iter496 != this->open_txns.end(); ++_iter496) + std::vector ::const_iterator _iter498; + for (_iter498 = this->open_txns.begin(); _iter498 != this->open_txns.end(); ++_iter498) { - xfer += (*_iter496).write(oprot); + xfer += (*_iter498).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11503,13 +11639,13 @@ void swap(GetOpenTxnsInfoResponse &a, GetOpenTxnsInfoResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other497) { - txn_high_water_mark = other497.txn_high_water_mark; - open_txns = other497.open_txns; +GetOpenTxnsInfoResponse::GetOpenTxnsInfoResponse(const GetOpenTxnsInfoResponse& other499) { + txn_high_water_mark = other499.txn_high_water_mark; + open_txns = other499.open_txns; } -GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other498) { - txn_high_water_mark = other498.txn_high_water_mark; - open_txns = other498.open_txns; +GetOpenTxnsInfoResponse& GetOpenTxnsInfoResponse::operator=(const GetOpenTxnsInfoResponse& other500) { + txn_high_water_mark = other500.txn_high_water_mark; + open_txns = other500.open_txns; return *this; } void GetOpenTxnsInfoResponse::printTo(std::ostream& out) const { @@ -11568,15 +11704,15 @@ uint32_t GetOpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_SET) { { this->open_txns.clear(); - uint32_t _size499; - ::apache::thrift::protocol::TType _etype502; - xfer += iprot->readSetBegin(_etype502, _size499); - uint32_t _i503; - for (_i503 = 0; _i503 < _size499; ++_i503) + uint32_t _size501; + ::apache::thrift::protocol::TType _etype504; + xfer += iprot->readSetBegin(_etype504, _size501); + uint32_t _i505; + for (_i505 = 0; _i505 < _size501; ++_i505) { - int64_t _elem504; - xfer += iprot->readI64(_elem504); - this->open_txns.insert(_elem504); + int64_t _elem506; + xfer += iprot->readI64(_elem506); + this->open_txns.insert(_elem506); } xfer += iprot->readSetEnd(); } @@ -11613,10 +11749,10 @@ uint32_t GetOpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("open_txns", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->open_txns.size())); - std::set ::const_iterator _iter505; - for (_iter505 = this->open_txns.begin(); _iter505 != this->open_txns.end(); ++_iter505) + std::set ::const_iterator _iter507; + for (_iter507 = this->open_txns.begin(); _iter507 != this->open_txns.end(); ++_iter507) { - xfer += oprot->writeI64((*_iter505)); + xfer += oprot->writeI64((*_iter507)); } xfer += oprot->writeSetEnd(); } @@ -11633,13 +11769,13 @@ void swap(GetOpenTxnsResponse &a, GetOpenTxnsResponse &b) { swap(a.open_txns, b.open_txns); } -GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other506) { - txn_high_water_mark = other506.txn_high_water_mark; - open_txns = other506.open_txns; +GetOpenTxnsResponse::GetOpenTxnsResponse(const GetOpenTxnsResponse& other508) { + txn_high_water_mark = other508.txn_high_water_mark; + open_txns = other508.open_txns; } -GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other507) { - txn_high_water_mark = other507.txn_high_water_mark; - open_txns = other507.open_txns; +GetOpenTxnsResponse& GetOpenTxnsResponse::operator=(const GetOpenTxnsResponse& other509) { + txn_high_water_mark = other509.txn_high_water_mark; + open_txns = other509.open_txns; return *this; } void GetOpenTxnsResponse::printTo(std::ostream& out) const { @@ -11782,19 +11918,19 @@ void swap(OpenTxnRequest &a, OpenTxnRequest &b) { swap(a.__isset, b.__isset); } -OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other508) { - num_txns = other508.num_txns; - user = other508.user; - hostname = other508.hostname; - agentInfo = other508.agentInfo; - __isset = other508.__isset; +OpenTxnRequest::OpenTxnRequest(const OpenTxnRequest& other510) { + num_txns = other510.num_txns; + user = other510.user; + hostname = other510.hostname; + agentInfo = other510.agentInfo; + __isset = other510.__isset; } -OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other509) { - num_txns = other509.num_txns; - user = other509.user; - hostname = other509.hostname; - agentInfo = other509.agentInfo; - __isset = other509.__isset; +OpenTxnRequest& OpenTxnRequest::operator=(const OpenTxnRequest& other511) { + num_txns = other511.num_txns; + user = other511.user; + hostname = other511.hostname; + agentInfo = other511.agentInfo; + __isset = other511.__isset; return *this; } void OpenTxnRequest::printTo(std::ostream& out) const { @@ -11842,14 +11978,14 @@ uint32_t OpenTxnsResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->txn_ids.clear(); - uint32_t _size510; - ::apache::thrift::protocol::TType _etype513; - xfer += iprot->readListBegin(_etype513, _size510); - this->txn_ids.resize(_size510); - uint32_t _i514; - for (_i514 = 0; _i514 < _size510; ++_i514) + uint32_t _size512; + ::apache::thrift::protocol::TType _etype515; + xfer += iprot->readListBegin(_etype515, _size512); + this->txn_ids.resize(_size512); + uint32_t _i516; + for (_i516 = 0; _i516 < _size512; ++_i516) { - xfer += iprot->readI64(this->txn_ids[_i514]); + xfer += iprot->readI64(this->txn_ids[_i516]); } xfer += iprot->readListEnd(); } @@ -11880,10 +12016,10 @@ uint32_t OpenTxnsResponse::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("txn_ids", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->txn_ids.size())); - std::vector ::const_iterator _iter515; - for (_iter515 = this->txn_ids.begin(); _iter515 != this->txn_ids.end(); ++_iter515) + std::vector ::const_iterator _iter517; + for (_iter517 = this->txn_ids.begin(); _iter517 != this->txn_ids.end(); ++_iter517) { - xfer += oprot->writeI64((*_iter515)); + xfer += oprot->writeI64((*_iter517)); } xfer += oprot->writeListEnd(); } @@ -11899,11 +12035,11 @@ void swap(OpenTxnsResponse &a, OpenTxnsResponse &b) { swap(a.txn_ids, b.txn_ids); } -OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other516) { - txn_ids = other516.txn_ids; +OpenTxnsResponse::OpenTxnsResponse(const OpenTxnsResponse& other518) { + txn_ids = other518.txn_ids; } -OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other517) { - txn_ids = other517.txn_ids; +OpenTxnsResponse& OpenTxnsResponse::operator=(const OpenTxnsResponse& other519) { + txn_ids = other519.txn_ids; return *this; } void OpenTxnsResponse::printTo(std::ostream& out) const { @@ -11985,11 +12121,11 @@ void swap(AbortTxnRequest &a, AbortTxnRequest &b) { swap(a.txnid, b.txnid); } -AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other518) { - txnid = other518.txnid; +AbortTxnRequest::AbortTxnRequest(const AbortTxnRequest& other520) { + txnid = other520.txnid; } -AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other519) { - txnid = other519.txnid; +AbortTxnRequest& AbortTxnRequest::operator=(const AbortTxnRequest& other521) { + txnid = other521.txnid; return *this; } void AbortTxnRequest::printTo(std::ostream& out) const { @@ -12071,11 +12207,11 @@ void swap(CommitTxnRequest &a, CommitTxnRequest &b) { swap(a.txnid, b.txnid); } -CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other520) { - txnid = other520.txnid; +CommitTxnRequest::CommitTxnRequest(const CommitTxnRequest& other522) { + txnid = other522.txnid; } -CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other521) { - txnid = other521.txnid; +CommitTxnRequest& CommitTxnRequest::operator=(const CommitTxnRequest& other523) { + txnid = other523.txnid; return *this; } void CommitTxnRequest::printTo(std::ostream& out) const { @@ -12138,9 +12274,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast522; - xfer += iprot->readI32(ecast522); - this->type = (LockType::type)ecast522; + int32_t ecast524; + xfer += iprot->readI32(ecast524); + this->type = (LockType::type)ecast524; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -12148,9 +12284,9 @@ uint32_t LockComponent::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast523; - xfer += iprot->readI32(ecast523); - this->level = (LockLevel::type)ecast523; + int32_t ecast525; + xfer += iprot->readI32(ecast525); + this->level = (LockLevel::type)ecast525; isset_level = true; } else { xfer += iprot->skip(ftype); @@ -12240,21 +12376,21 @@ void swap(LockComponent &a, LockComponent &b) { swap(a.__isset, b.__isset); } -LockComponent::LockComponent(const LockComponent& other524) { - type = other524.type; - level = other524.level; - dbname = other524.dbname; - tablename = other524.tablename; - partitionname = other524.partitionname; - __isset = other524.__isset; -} -LockComponent& LockComponent::operator=(const LockComponent& other525) { - type = other525.type; - level = other525.level; - dbname = other525.dbname; - tablename = other525.tablename; - partitionname = other525.partitionname; - __isset = other525.__isset; +LockComponent::LockComponent(const LockComponent& other526) { + type = other526.type; + level = other526.level; + dbname = other526.dbname; + tablename = other526.tablename; + partitionname = other526.partitionname; + __isset = other526.__isset; +} +LockComponent& LockComponent::operator=(const LockComponent& other527) { + type = other527.type; + level = other527.level; + dbname = other527.dbname; + tablename = other527.tablename; + partitionname = other527.partitionname; + __isset = other527.__isset; return *this; } void LockComponent::printTo(std::ostream& out) const { @@ -12323,14 +12459,14 @@ uint32_t LockRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->component.clear(); - uint32_t _size526; - ::apache::thrift::protocol::TType _etype529; - xfer += iprot->readListBegin(_etype529, _size526); - this->component.resize(_size526); - uint32_t _i530; - for (_i530 = 0; _i530 < _size526; ++_i530) + uint32_t _size528; + ::apache::thrift::protocol::TType _etype531; + xfer += iprot->readListBegin(_etype531, _size528); + this->component.resize(_size528); + uint32_t _i532; + for (_i532 = 0; _i532 < _size528; ++_i532) { - xfer += this->component[_i530].read(iprot); + xfer += this->component[_i532].read(iprot); } xfer += iprot->readListEnd(); } @@ -12397,10 +12533,10 @@ uint32_t LockRequest::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("component", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->component.size())); - std::vector ::const_iterator _iter531; - for (_iter531 = this->component.begin(); _iter531 != this->component.end(); ++_iter531) + std::vector ::const_iterator _iter533; + for (_iter533 = this->component.begin(); _iter533 != this->component.end(); ++_iter533) { - xfer += (*_iter531).write(oprot); + xfer += (*_iter533).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12439,21 +12575,21 @@ void swap(LockRequest &a, LockRequest &b) { swap(a.__isset, b.__isset); } -LockRequest::LockRequest(const LockRequest& other532) { - component = other532.component; - txnid = other532.txnid; - user = other532.user; - hostname = other532.hostname; - agentInfo = other532.agentInfo; - __isset = other532.__isset; -} -LockRequest& LockRequest::operator=(const LockRequest& other533) { - component = other533.component; - txnid = other533.txnid; - user = other533.user; - hostname = other533.hostname; - agentInfo = other533.agentInfo; - __isset = other533.__isset; +LockRequest::LockRequest(const LockRequest& other534) { + component = other534.component; + txnid = other534.txnid; + user = other534.user; + hostname = other534.hostname; + agentInfo = other534.agentInfo; + __isset = other534.__isset; +} +LockRequest& LockRequest::operator=(const LockRequest& other535) { + component = other535.component; + txnid = other535.txnid; + user = other535.user; + hostname = other535.hostname; + agentInfo = other535.agentInfo; + __isset = other535.__isset; return *this; } void LockRequest::printTo(std::ostream& out) const { @@ -12513,9 +12649,9 @@ uint32_t LockResponse::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 2: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast534; - xfer += iprot->readI32(ecast534); - this->state = (LockState::type)ecast534; + int32_t ecast536; + xfer += iprot->readI32(ecast536); + this->state = (LockState::type)ecast536; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -12561,13 +12697,13 @@ void swap(LockResponse &a, LockResponse &b) { swap(a.state, b.state); } -LockResponse::LockResponse(const LockResponse& other535) { - lockid = other535.lockid; - state = other535.state; +LockResponse::LockResponse(const LockResponse& other537) { + lockid = other537.lockid; + state = other537.state; } -LockResponse& LockResponse::operator=(const LockResponse& other536) { - lockid = other536.lockid; - state = other536.state; +LockResponse& LockResponse::operator=(const LockResponse& other538) { + lockid = other538.lockid; + state = other538.state; return *this; } void LockResponse::printTo(std::ostream& out) const { @@ -12689,17 +12825,17 @@ void swap(CheckLockRequest &a, CheckLockRequest &b) { swap(a.__isset, b.__isset); } -CheckLockRequest::CheckLockRequest(const CheckLockRequest& other537) { - lockid = other537.lockid; - txnid = other537.txnid; - elapsed_ms = other537.elapsed_ms; - __isset = other537.__isset; +CheckLockRequest::CheckLockRequest(const CheckLockRequest& other539) { + lockid = other539.lockid; + txnid = other539.txnid; + elapsed_ms = other539.elapsed_ms; + __isset = other539.__isset; } -CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other538) { - lockid = other538.lockid; - txnid = other538.txnid; - elapsed_ms = other538.elapsed_ms; - __isset = other538.__isset; +CheckLockRequest& CheckLockRequest::operator=(const CheckLockRequest& other540) { + lockid = other540.lockid; + txnid = other540.txnid; + elapsed_ms = other540.elapsed_ms; + __isset = other540.__isset; return *this; } void CheckLockRequest::printTo(std::ostream& out) const { @@ -12783,11 +12919,11 @@ void swap(UnlockRequest &a, UnlockRequest &b) { swap(a.lockid, b.lockid); } -UnlockRequest::UnlockRequest(const UnlockRequest& other539) { - lockid = other539.lockid; +UnlockRequest::UnlockRequest(const UnlockRequest& other541) { + lockid = other541.lockid; } -UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other540) { - lockid = other540.lockid; +UnlockRequest& UnlockRequest::operator=(const UnlockRequest& other542) { + lockid = other542.lockid; return *this; } void UnlockRequest::printTo(std::ostream& out) const { @@ -12926,19 +13062,19 @@ void swap(ShowLocksRequest &a, ShowLocksRequest &b) { swap(a.__isset, b.__isset); } -ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other541) { - dbname = other541.dbname; - tablename = other541.tablename; - partname = other541.partname; - isExtended = other541.isExtended; - __isset = other541.__isset; +ShowLocksRequest::ShowLocksRequest(const ShowLocksRequest& other543) { + dbname = other543.dbname; + tablename = other543.tablename; + partname = other543.partname; + isExtended = other543.isExtended; + __isset = other543.__isset; } -ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other542) { - dbname = other542.dbname; - tablename = other542.tablename; - partname = other542.partname; - isExtended = other542.isExtended; - __isset = other542.__isset; +ShowLocksRequest& ShowLocksRequest::operator=(const ShowLocksRequest& other544) { + dbname = other544.dbname; + tablename = other544.tablename; + partname = other544.partname; + isExtended = other544.isExtended; + __isset = other544.__isset; return *this; } void ShowLocksRequest::printTo(std::ostream& out) const { @@ -13091,9 +13227,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast543; - xfer += iprot->readI32(ecast543); - this->state = (LockState::type)ecast543; + int32_t ecast545; + xfer += iprot->readI32(ecast545); + this->state = (LockState::type)ecast545; isset_state = true; } else { xfer += iprot->skip(ftype); @@ -13101,9 +13237,9 @@ uint32_t ShowLocksResponseElement::read(::apache::thrift::protocol::TProtocol* i break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast544; - xfer += iprot->readI32(ecast544); - this->type = (LockType::type)ecast544; + int32_t ecast546; + xfer += iprot->readI32(ecast546); + this->type = (LockType::type)ecast546; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -13319,43 +13455,43 @@ void swap(ShowLocksResponseElement &a, ShowLocksResponseElement &b) { swap(a.__isset, b.__isset); } -ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other545) { - lockid = other545.lockid; - dbname = other545.dbname; - tablename = other545.tablename; - partname = other545.partname; - state = other545.state; - type = other545.type; - txnid = other545.txnid; - lastheartbeat = other545.lastheartbeat; - acquiredat = other545.acquiredat; - user = other545.user; - hostname = other545.hostname; - heartbeatCount = other545.heartbeatCount; - agentInfo = other545.agentInfo; - blockedByExtId = other545.blockedByExtId; - blockedByIntId = other545.blockedByIntId; - lockIdInternal = other545.lockIdInternal; - __isset = other545.__isset; -} -ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other546) { - lockid = other546.lockid; - dbname = other546.dbname; - tablename = other546.tablename; - partname = other546.partname; - state = other546.state; - type = other546.type; - txnid = other546.txnid; - lastheartbeat = other546.lastheartbeat; - acquiredat = other546.acquiredat; - user = other546.user; - hostname = other546.hostname; - heartbeatCount = other546.heartbeatCount; - agentInfo = other546.agentInfo; - blockedByExtId = other546.blockedByExtId; - blockedByIntId = other546.blockedByIntId; - lockIdInternal = other546.lockIdInternal; - __isset = other546.__isset; +ShowLocksResponseElement::ShowLocksResponseElement(const ShowLocksResponseElement& other547) { + lockid = other547.lockid; + dbname = other547.dbname; + tablename = other547.tablename; + partname = other547.partname; + state = other547.state; + type = other547.type; + txnid = other547.txnid; + lastheartbeat = other547.lastheartbeat; + acquiredat = other547.acquiredat; + user = other547.user; + hostname = other547.hostname; + heartbeatCount = other547.heartbeatCount; + agentInfo = other547.agentInfo; + blockedByExtId = other547.blockedByExtId; + blockedByIntId = other547.blockedByIntId; + lockIdInternal = other547.lockIdInternal; + __isset = other547.__isset; +} +ShowLocksResponseElement& ShowLocksResponseElement::operator=(const ShowLocksResponseElement& other548) { + lockid = other548.lockid; + dbname = other548.dbname; + tablename = other548.tablename; + partname = other548.partname; + state = other548.state; + type = other548.type; + txnid = other548.txnid; + lastheartbeat = other548.lastheartbeat; + acquiredat = other548.acquiredat; + user = other548.user; + hostname = other548.hostname; + heartbeatCount = other548.heartbeatCount; + agentInfo = other548.agentInfo; + blockedByExtId = other548.blockedByExtId; + blockedByIntId = other548.blockedByIntId; + lockIdInternal = other548.lockIdInternal; + __isset = other548.__isset; return *this; } void ShowLocksResponseElement::printTo(std::ostream& out) const { @@ -13414,14 +13550,14 @@ uint32_t ShowLocksResponse::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->locks.clear(); - uint32_t _size547; - ::apache::thrift::protocol::TType _etype550; - xfer += iprot->readListBegin(_etype550, _size547); - this->locks.resize(_size547); - uint32_t _i551; - for (_i551 = 0; _i551 < _size547; ++_i551) + uint32_t _size549; + ::apache::thrift::protocol::TType _etype552; + xfer += iprot->readListBegin(_etype552, _size549); + this->locks.resize(_size549); + uint32_t _i553; + for (_i553 = 0; _i553 < _size549; ++_i553) { - xfer += this->locks[_i551].read(iprot); + xfer += this->locks[_i553].read(iprot); } xfer += iprot->readListEnd(); } @@ -13450,10 +13586,10 @@ uint32_t ShowLocksResponse::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("locks", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->locks.size())); - std::vector ::const_iterator _iter552; - for (_iter552 = this->locks.begin(); _iter552 != this->locks.end(); ++_iter552) + std::vector ::const_iterator _iter554; + for (_iter554 = this->locks.begin(); _iter554 != this->locks.end(); ++_iter554) { - xfer += (*_iter552).write(oprot); + xfer += (*_iter554).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13470,13 +13606,13 @@ void swap(ShowLocksResponse &a, ShowLocksResponse &b) { swap(a.__isset, b.__isset); } -ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other553) { - locks = other553.locks; - __isset = other553.__isset; +ShowLocksResponse::ShowLocksResponse(const ShowLocksResponse& other555) { + locks = other555.locks; + __isset = other555.__isset; } -ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other554) { - locks = other554.locks; - __isset = other554.__isset; +ShowLocksResponse& ShowLocksResponse::operator=(const ShowLocksResponse& other556) { + locks = other556.locks; + __isset = other556.__isset; return *this; } void ShowLocksResponse::printTo(std::ostream& out) const { @@ -13577,15 +13713,15 @@ void swap(HeartbeatRequest &a, HeartbeatRequest &b) { swap(a.__isset, b.__isset); } -HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other555) { - lockid = other555.lockid; - txnid = other555.txnid; - __isset = other555.__isset; +HeartbeatRequest::HeartbeatRequest(const HeartbeatRequest& other557) { + lockid = other557.lockid; + txnid = other557.txnid; + __isset = other557.__isset; } -HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other556) { - lockid = other556.lockid; - txnid = other556.txnid; - __isset = other556.__isset; +HeartbeatRequest& HeartbeatRequest::operator=(const HeartbeatRequest& other558) { + lockid = other558.lockid; + txnid = other558.txnid; + __isset = other558.__isset; return *this; } void HeartbeatRequest::printTo(std::ostream& out) const { @@ -13688,13 +13824,13 @@ void swap(HeartbeatTxnRangeRequest &a, HeartbeatTxnRangeRequest &b) { swap(a.max, b.max); } -HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other557) { - min = other557.min; - max = other557.max; +HeartbeatTxnRangeRequest::HeartbeatTxnRangeRequest(const HeartbeatTxnRangeRequest& other559) { + min = other559.min; + max = other559.max; } -HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other558) { - min = other558.min; - max = other558.max; +HeartbeatTxnRangeRequest& HeartbeatTxnRangeRequest::operator=(const HeartbeatTxnRangeRequest& other560) { + min = other560.min; + max = other560.max; return *this; } void HeartbeatTxnRangeRequest::printTo(std::ostream& out) const { @@ -13745,15 +13881,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->aborted.clear(); - uint32_t _size559; - ::apache::thrift::protocol::TType _etype562; - xfer += iprot->readSetBegin(_etype562, _size559); - uint32_t _i563; - for (_i563 = 0; _i563 < _size559; ++_i563) + uint32_t _size561; + ::apache::thrift::protocol::TType _etype564; + xfer += iprot->readSetBegin(_etype564, _size561); + uint32_t _i565; + for (_i565 = 0; _i565 < _size561; ++_i565) { - int64_t _elem564; - xfer += iprot->readI64(_elem564); - this->aborted.insert(_elem564); + int64_t _elem566; + xfer += iprot->readI64(_elem566); + this->aborted.insert(_elem566); } xfer += iprot->readSetEnd(); } @@ -13766,15 +13902,15 @@ uint32_t HeartbeatTxnRangeResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_SET) { { this->nosuch.clear(); - uint32_t _size565; - ::apache::thrift::protocol::TType _etype568; - xfer += iprot->readSetBegin(_etype568, _size565); - uint32_t _i569; - for (_i569 = 0; _i569 < _size565; ++_i569) + uint32_t _size567; + ::apache::thrift::protocol::TType _etype570; + xfer += iprot->readSetBegin(_etype570, _size567); + uint32_t _i571; + for (_i571 = 0; _i571 < _size567; ++_i571) { - int64_t _elem570; - xfer += iprot->readI64(_elem570); - this->nosuch.insert(_elem570); + int64_t _elem572; + xfer += iprot->readI64(_elem572); + this->nosuch.insert(_elem572); } xfer += iprot->readSetEnd(); } @@ -13807,10 +13943,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("aborted", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->aborted.size())); - std::set ::const_iterator _iter571; - for (_iter571 = this->aborted.begin(); _iter571 != this->aborted.end(); ++_iter571) + std::set ::const_iterator _iter573; + for (_iter573 = this->aborted.begin(); _iter573 != this->aborted.end(); ++_iter573) { - xfer += oprot->writeI64((*_iter571)); + xfer += oprot->writeI64((*_iter573)); } xfer += oprot->writeSetEnd(); } @@ -13819,10 +13955,10 @@ uint32_t HeartbeatTxnRangeResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("nosuch", ::apache::thrift::protocol::T_SET, 2); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_I64, static_cast(this->nosuch.size())); - std::set ::const_iterator _iter572; - for (_iter572 = this->nosuch.begin(); _iter572 != this->nosuch.end(); ++_iter572) + std::set ::const_iterator _iter574; + for (_iter574 = this->nosuch.begin(); _iter574 != this->nosuch.end(); ++_iter574) { - xfer += oprot->writeI64((*_iter572)); + xfer += oprot->writeI64((*_iter574)); } xfer += oprot->writeSetEnd(); } @@ -13839,13 +13975,13 @@ void swap(HeartbeatTxnRangeResponse &a, HeartbeatTxnRangeResponse &b) { swap(a.nosuch, b.nosuch); } -HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other573) { - aborted = other573.aborted; - nosuch = other573.nosuch; +HeartbeatTxnRangeResponse::HeartbeatTxnRangeResponse(const HeartbeatTxnRangeResponse& other575) { + aborted = other575.aborted; + nosuch = other575.nosuch; } -HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other574) { - aborted = other574.aborted; - nosuch = other574.nosuch; +HeartbeatTxnRangeResponse& HeartbeatTxnRangeResponse::operator=(const HeartbeatTxnRangeResponse& other576) { + aborted = other576.aborted; + nosuch = other576.nosuch; return *this; } void HeartbeatTxnRangeResponse::printTo(std::ostream& out) const { @@ -13933,9 +14069,9 @@ uint32_t CompactionRequest::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast575; - xfer += iprot->readI32(ecast575); - this->type = (CompactionType::type)ecast575; + int32_t ecast577; + xfer += iprot->readI32(ecast577); + this->type = (CompactionType::type)ecast577; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14009,21 +14145,21 @@ void swap(CompactionRequest &a, CompactionRequest &b) { swap(a.__isset, b.__isset); } -CompactionRequest::CompactionRequest(const CompactionRequest& other576) { - dbname = other576.dbname; - tablename = other576.tablename; - partitionname = other576.partitionname; - type = other576.type; - runas = other576.runas; - __isset = other576.__isset; -} -CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other577) { - dbname = other577.dbname; - tablename = other577.tablename; - partitionname = other577.partitionname; - type = other577.type; - runas = other577.runas; - __isset = other577.__isset; +CompactionRequest::CompactionRequest(const CompactionRequest& other578) { + dbname = other578.dbname; + tablename = other578.tablename; + partitionname = other578.partitionname; + type = other578.type; + runas = other578.runas; + __isset = other578.__isset; +} +CompactionRequest& CompactionRequest::operator=(const CompactionRequest& other579) { + dbname = other579.dbname; + tablename = other579.tablename; + partitionname = other579.partitionname; + type = other579.type; + runas = other579.runas; + __isset = other579.__isset; return *this; } void CompactionRequest::printTo(std::ostream& out) const { @@ -14086,11 +14222,11 @@ void swap(ShowCompactRequest &a, ShowCompactRequest &b) { (void) b; } -ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other578) { - (void) other578; +ShowCompactRequest::ShowCompactRequest(const ShowCompactRequest& other580) { + (void) other580; } -ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other579) { - (void) other579; +ShowCompactRequest& ShowCompactRequest::operator=(const ShowCompactRequest& other581) { + (void) other581; return *this; } void ShowCompactRequest::printTo(std::ostream& out) const { @@ -14211,9 +14347,9 @@ uint32_t ShowCompactResponseElement::read(::apache::thrift::protocol::TProtocol* break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast580; - xfer += iprot->readI32(ecast580); - this->type = (CompactionType::type)ecast580; + int32_t ecast582; + xfer += iprot->readI32(ecast582); + this->type = (CompactionType::type)ecast582; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -14386,35 +14522,35 @@ void swap(ShowCompactResponseElement &a, ShowCompactResponseElement &b) { swap(a.__isset, b.__isset); } -ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other581) { - dbname = other581.dbname; - tablename = other581.tablename; - partitionname = other581.partitionname; - type = other581.type; - state = other581.state; - workerid = other581.workerid; - start = other581.start; - runAs = other581.runAs; - hightestTxnId = other581.hightestTxnId; - metaInfo = other581.metaInfo; - endTime = other581.endTime; - hadoopJobId = other581.hadoopJobId; - __isset = other581.__isset; -} -ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other582) { - dbname = other582.dbname; - tablename = other582.tablename; - partitionname = other582.partitionname; - type = other582.type; - state = other582.state; - workerid = other582.workerid; - start = other582.start; - runAs = other582.runAs; - hightestTxnId = other582.hightestTxnId; - metaInfo = other582.metaInfo; - endTime = other582.endTime; - hadoopJobId = other582.hadoopJobId; - __isset = other582.__isset; +ShowCompactResponseElement::ShowCompactResponseElement(const ShowCompactResponseElement& other583) { + dbname = other583.dbname; + tablename = other583.tablename; + partitionname = other583.partitionname; + type = other583.type; + state = other583.state; + workerid = other583.workerid; + start = other583.start; + runAs = other583.runAs; + hightestTxnId = other583.hightestTxnId; + metaInfo = other583.metaInfo; + endTime = other583.endTime; + hadoopJobId = other583.hadoopJobId; + __isset = other583.__isset; +} +ShowCompactResponseElement& ShowCompactResponseElement::operator=(const ShowCompactResponseElement& other584) { + dbname = other584.dbname; + tablename = other584.tablename; + partitionname = other584.partitionname; + type = other584.type; + state = other584.state; + workerid = other584.workerid; + start = other584.start; + runAs = other584.runAs; + hightestTxnId = other584.hightestTxnId; + metaInfo = other584.metaInfo; + endTime = other584.endTime; + hadoopJobId = other584.hadoopJobId; + __isset = other584.__isset; return *this; } void ShowCompactResponseElement::printTo(std::ostream& out) const { @@ -14470,14 +14606,14 @@ uint32_t ShowCompactResponse::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->compacts.clear(); - uint32_t _size583; - ::apache::thrift::protocol::TType _etype586; - xfer += iprot->readListBegin(_etype586, _size583); - this->compacts.resize(_size583); - uint32_t _i587; - for (_i587 = 0; _i587 < _size583; ++_i587) + uint32_t _size585; + ::apache::thrift::protocol::TType _etype588; + xfer += iprot->readListBegin(_etype588, _size585); + this->compacts.resize(_size585); + uint32_t _i589; + for (_i589 = 0; _i589 < _size585; ++_i589) { - xfer += this->compacts[_i587].read(iprot); + xfer += this->compacts[_i589].read(iprot); } xfer += iprot->readListEnd(); } @@ -14508,10 +14644,10 @@ uint32_t ShowCompactResponse::write(::apache::thrift::protocol::TProtocol* oprot xfer += oprot->writeFieldBegin("compacts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->compacts.size())); - std::vector ::const_iterator _iter588; - for (_iter588 = this->compacts.begin(); _iter588 != this->compacts.end(); ++_iter588) + std::vector ::const_iterator _iter590; + for (_iter590 = this->compacts.begin(); _iter590 != this->compacts.end(); ++_iter590) { - xfer += (*_iter588).write(oprot); + xfer += (*_iter590).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14527,11 +14663,11 @@ void swap(ShowCompactResponse &a, ShowCompactResponse &b) { swap(a.compacts, b.compacts); } -ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other589) { - compacts = other589.compacts; +ShowCompactResponse::ShowCompactResponse(const ShowCompactResponse& other591) { + compacts = other591.compacts; } -ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other590) { - compacts = other590.compacts; +ShowCompactResponse& ShowCompactResponse::operator=(const ShowCompactResponse& other592) { + compacts = other592.compacts; return *this; } void ShowCompactResponse::printTo(std::ostream& out) const { @@ -14615,14 +14751,14 @@ uint32_t AddDynamicPartitions::read(::apache::thrift::protocol::TProtocol* iprot if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionnames.clear(); - uint32_t _size591; - ::apache::thrift::protocol::TType _etype594; - xfer += iprot->readListBegin(_etype594, _size591); - this->partitionnames.resize(_size591); - uint32_t _i595; - for (_i595 = 0; _i595 < _size591; ++_i595) + uint32_t _size593; + ::apache::thrift::protocol::TType _etype596; + xfer += iprot->readListBegin(_etype596, _size593); + this->partitionnames.resize(_size593); + uint32_t _i597; + for (_i597 = 0; _i597 < _size593; ++_i597) { - xfer += iprot->readString(this->partitionnames[_i595]); + xfer += iprot->readString(this->partitionnames[_i597]); } xfer += iprot->readListEnd(); } @@ -14671,10 +14807,10 @@ uint32_t AddDynamicPartitions::write(::apache::thrift::protocol::TProtocol* opro xfer += oprot->writeFieldBegin("partitionnames", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionnames.size())); - std::vector ::const_iterator _iter596; - for (_iter596 = this->partitionnames.begin(); _iter596 != this->partitionnames.end(); ++_iter596) + std::vector ::const_iterator _iter598; + for (_iter598 = this->partitionnames.begin(); _iter598 != this->partitionnames.end(); ++_iter598) { - xfer += oprot->writeString((*_iter596)); + xfer += oprot->writeString((*_iter598)); } xfer += oprot->writeListEnd(); } @@ -14693,17 +14829,17 @@ void swap(AddDynamicPartitions &a, AddDynamicPartitions &b) { swap(a.partitionnames, b.partitionnames); } -AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other597) { - txnid = other597.txnid; - dbname = other597.dbname; - tablename = other597.tablename; - partitionnames = other597.partitionnames; +AddDynamicPartitions::AddDynamicPartitions(const AddDynamicPartitions& other599) { + txnid = other599.txnid; + dbname = other599.dbname; + tablename = other599.tablename; + partitionnames = other599.partitionnames; } -AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other598) { - txnid = other598.txnid; - dbname = other598.dbname; - tablename = other598.tablename; - partitionnames = other598.partitionnames; +AddDynamicPartitions& AddDynamicPartitions::operator=(const AddDynamicPartitions& other600) { + txnid = other600.txnid; + dbname = other600.dbname; + tablename = other600.tablename; + partitionnames = other600.partitionnames; return *this; } void AddDynamicPartitions::printTo(std::ostream& out) const { @@ -14808,15 +14944,15 @@ void swap(NotificationEventRequest &a, NotificationEventRequest &b) { swap(a.__isset, b.__isset); } -NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other599) { - lastEvent = other599.lastEvent; - maxEvents = other599.maxEvents; - __isset = other599.__isset; +NotificationEventRequest::NotificationEventRequest(const NotificationEventRequest& other601) { + lastEvent = other601.lastEvent; + maxEvents = other601.maxEvents; + __isset = other601.__isset; } -NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other600) { - lastEvent = other600.lastEvent; - maxEvents = other600.maxEvents; - __isset = other600.__isset; +NotificationEventRequest& NotificationEventRequest::operator=(const NotificationEventRequest& other602) { + lastEvent = other602.lastEvent; + maxEvents = other602.maxEvents; + __isset = other602.__isset; return *this; } void NotificationEventRequest::printTo(std::ostream& out) const { @@ -14998,23 +15134,23 @@ void swap(NotificationEvent &a, NotificationEvent &b) { swap(a.__isset, b.__isset); } -NotificationEvent::NotificationEvent(const NotificationEvent& other601) { - eventId = other601.eventId; - eventTime = other601.eventTime; - eventType = other601.eventType; - dbName = other601.dbName; - tableName = other601.tableName; - message = other601.message; - __isset = other601.__isset; -} -NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other602) { - eventId = other602.eventId; - eventTime = other602.eventTime; - eventType = other602.eventType; - dbName = other602.dbName; - tableName = other602.tableName; - message = other602.message; - __isset = other602.__isset; +NotificationEvent::NotificationEvent(const NotificationEvent& other603) { + eventId = other603.eventId; + eventTime = other603.eventTime; + eventType = other603.eventType; + dbName = other603.dbName; + tableName = other603.tableName; + message = other603.message; + __isset = other603.__isset; +} +NotificationEvent& NotificationEvent::operator=(const NotificationEvent& other604) { + eventId = other604.eventId; + eventTime = other604.eventTime; + eventType = other604.eventType; + dbName = other604.dbName; + tableName = other604.tableName; + message = other604.message; + __isset = other604.__isset; return *this; } void NotificationEvent::printTo(std::ostream& out) const { @@ -15064,14 +15200,14 @@ uint32_t NotificationEventResponse::read(::apache::thrift::protocol::TProtocol* if (ftype == ::apache::thrift::protocol::T_LIST) { { this->events.clear(); - uint32_t _size603; - ::apache::thrift::protocol::TType _etype606; - xfer += iprot->readListBegin(_etype606, _size603); - this->events.resize(_size603); - uint32_t _i607; - for (_i607 = 0; _i607 < _size603; ++_i607) + uint32_t _size605; + ::apache::thrift::protocol::TType _etype608; + xfer += iprot->readListBegin(_etype608, _size605); + this->events.resize(_size605); + uint32_t _i609; + for (_i609 = 0; _i609 < _size605; ++_i609) { - xfer += this->events[_i607].read(iprot); + xfer += this->events[_i609].read(iprot); } xfer += iprot->readListEnd(); } @@ -15102,10 +15238,10 @@ uint32_t NotificationEventResponse::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("events", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->events.size())); - std::vector ::const_iterator _iter608; - for (_iter608 = this->events.begin(); _iter608 != this->events.end(); ++_iter608) + std::vector ::const_iterator _iter610; + for (_iter610 = this->events.begin(); _iter610 != this->events.end(); ++_iter610) { - xfer += (*_iter608).write(oprot); + xfer += (*_iter610).write(oprot); } xfer += oprot->writeListEnd(); } @@ -15121,11 +15257,11 @@ void swap(NotificationEventResponse &a, NotificationEventResponse &b) { swap(a.events, b.events); } -NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other609) { - events = other609.events; +NotificationEventResponse::NotificationEventResponse(const NotificationEventResponse& other611) { + events = other611.events; } -NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other610) { - events = other610.events; +NotificationEventResponse& NotificationEventResponse::operator=(const NotificationEventResponse& other612) { + events = other612.events; return *this; } void NotificationEventResponse::printTo(std::ostream& out) const { @@ -15207,11 +15343,11 @@ void swap(CurrentNotificationEventId &a, CurrentNotificationEventId &b) { swap(a.eventId, b.eventId); } -CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other611) { - eventId = other611.eventId; +CurrentNotificationEventId::CurrentNotificationEventId(const CurrentNotificationEventId& other613) { + eventId = other613.eventId; } -CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other612) { - eventId = other612.eventId; +CurrentNotificationEventId& CurrentNotificationEventId::operator=(const CurrentNotificationEventId& other614) { + eventId = other614.eventId; return *this; } void CurrentNotificationEventId::printTo(std::ostream& out) const { @@ -15256,14 +15392,14 @@ uint32_t InsertEventRequestData::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->filesAdded.clear(); - uint32_t _size613; - ::apache::thrift::protocol::TType _etype616; - xfer += iprot->readListBegin(_etype616, _size613); - this->filesAdded.resize(_size613); - uint32_t _i617; - for (_i617 = 0; _i617 < _size613; ++_i617) + uint32_t _size615; + ::apache::thrift::protocol::TType _etype618; + xfer += iprot->readListBegin(_etype618, _size615); + this->filesAdded.resize(_size615); + uint32_t _i619; + for (_i619 = 0; _i619 < _size615; ++_i619) { - xfer += iprot->readString(this->filesAdded[_i617]); + xfer += iprot->readString(this->filesAdded[_i619]); } xfer += iprot->readListEnd(); } @@ -15294,10 +15430,10 @@ uint32_t InsertEventRequestData::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("filesAdded", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->filesAdded.size())); - std::vector ::const_iterator _iter618; - for (_iter618 = this->filesAdded.begin(); _iter618 != this->filesAdded.end(); ++_iter618) + std::vector ::const_iterator _iter620; + for (_iter620 = this->filesAdded.begin(); _iter620 != this->filesAdded.end(); ++_iter620) { - xfer += oprot->writeString((*_iter618)); + xfer += oprot->writeString((*_iter620)); } xfer += oprot->writeListEnd(); } @@ -15313,11 +15449,11 @@ void swap(InsertEventRequestData &a, InsertEventRequestData &b) { swap(a.filesAdded, b.filesAdded); } -InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other619) { - filesAdded = other619.filesAdded; +InsertEventRequestData::InsertEventRequestData(const InsertEventRequestData& other621) { + filesAdded = other621.filesAdded; } -InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other620) { - filesAdded = other620.filesAdded; +InsertEventRequestData& InsertEventRequestData::operator=(const InsertEventRequestData& other622) { + filesAdded = other622.filesAdded; return *this; } void InsertEventRequestData::printTo(std::ostream& out) const { @@ -15397,13 +15533,13 @@ void swap(FireEventRequestData &a, FireEventRequestData &b) { swap(a.__isset, b.__isset); } -FireEventRequestData::FireEventRequestData(const FireEventRequestData& other621) { - insertData = other621.insertData; - __isset = other621.__isset; +FireEventRequestData::FireEventRequestData(const FireEventRequestData& other623) { + insertData = other623.insertData; + __isset = other623.__isset; } -FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other622) { - insertData = other622.insertData; - __isset = other622.__isset; +FireEventRequestData& FireEventRequestData::operator=(const FireEventRequestData& other624) { + insertData = other624.insertData; + __isset = other624.__isset; return *this; } void FireEventRequestData::printTo(std::ostream& out) const { @@ -15500,14 +15636,14 @@ uint32_t FireEventRequest::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionVals.clear(); - uint32_t _size623; - ::apache::thrift::protocol::TType _etype626; - xfer += iprot->readListBegin(_etype626, _size623); - this->partitionVals.resize(_size623); - uint32_t _i627; - for (_i627 = 0; _i627 < _size623; ++_i627) + uint32_t _size625; + ::apache::thrift::protocol::TType _etype628; + xfer += iprot->readListBegin(_etype628, _size625); + this->partitionVals.resize(_size625); + uint32_t _i629; + for (_i629 = 0; _i629 < _size625; ++_i629) { - xfer += iprot->readString(this->partitionVals[_i627]); + xfer += iprot->readString(this->partitionVals[_i629]); } xfer += iprot->readListEnd(); } @@ -15559,10 +15695,10 @@ uint32_t FireEventRequest::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("partitionVals", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->partitionVals.size())); - std::vector ::const_iterator _iter628; - for (_iter628 = this->partitionVals.begin(); _iter628 != this->partitionVals.end(); ++_iter628) + std::vector ::const_iterator _iter630; + for (_iter630 = this->partitionVals.begin(); _iter630 != this->partitionVals.end(); ++_iter630) { - xfer += oprot->writeString((*_iter628)); + xfer += oprot->writeString((*_iter630)); } xfer += oprot->writeListEnd(); } @@ -15583,21 +15719,21 @@ void swap(FireEventRequest &a, FireEventRequest &b) { swap(a.__isset, b.__isset); } -FireEventRequest::FireEventRequest(const FireEventRequest& other629) { - successful = other629.successful; - data = other629.data; - dbName = other629.dbName; - tableName = other629.tableName; - partitionVals = other629.partitionVals; - __isset = other629.__isset; -} -FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other630) { - successful = other630.successful; - data = other630.data; - dbName = other630.dbName; - tableName = other630.tableName; - partitionVals = other630.partitionVals; - __isset = other630.__isset; +FireEventRequest::FireEventRequest(const FireEventRequest& other631) { + successful = other631.successful; + data = other631.data; + dbName = other631.dbName; + tableName = other631.tableName; + partitionVals = other631.partitionVals; + __isset = other631.__isset; +} +FireEventRequest& FireEventRequest::operator=(const FireEventRequest& other632) { + successful = other632.successful; + data = other632.data; + dbName = other632.dbName; + tableName = other632.tableName; + partitionVals = other632.partitionVals; + __isset = other632.__isset; return *this; } void FireEventRequest::printTo(std::ostream& out) const { @@ -15660,11 +15796,11 @@ void swap(FireEventResponse &a, FireEventResponse &b) { (void) b; } -FireEventResponse::FireEventResponse(const FireEventResponse& other631) { - (void) other631; +FireEventResponse::FireEventResponse(const FireEventResponse& other633) { + (void) other633; } -FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other632) { - (void) other632; +FireEventResponse& FireEventResponse::operator=(const FireEventResponse& other634) { + (void) other634; return *this; } void FireEventResponse::printTo(std::ostream& out) const { @@ -15745,11 +15881,11 @@ void swap(GetChangeVersionRequest &a, GetChangeVersionRequest &b) { swap(a.topic, b.topic); } -GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other633) { - topic = other633.topic; +GetChangeVersionRequest::GetChangeVersionRequest(const GetChangeVersionRequest& other635) { + topic = other635.topic; } -GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other634) { - topic = other634.topic; +GetChangeVersionRequest& GetChangeVersionRequest::operator=(const GetChangeVersionRequest& other636) { + topic = other636.topic; return *this; } void GetChangeVersionRequest::printTo(std::ostream& out) const { @@ -15831,11 +15967,11 @@ void swap(GetChangeVersionResult &a, GetChangeVersionResult &b) { swap(a.version, b.version); } -GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other635) { - version = other635.version; +GetChangeVersionResult::GetChangeVersionResult(const GetChangeVersionResult& other637) { + version = other637.version; } -GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other636) { - version = other636.version; +GetChangeVersionResult& GetChangeVersionResult::operator=(const GetChangeVersionResult& other638) { + version = other638.version; return *this; } void GetChangeVersionResult::printTo(std::ostream& out) const { @@ -15936,15 +16072,15 @@ void swap(MetadataPpdResult &a, MetadataPpdResult &b) { swap(a.__isset, b.__isset); } -MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other637) { - metadata = other637.metadata; - includeBitset = other637.includeBitset; - __isset = other637.__isset; +MetadataPpdResult::MetadataPpdResult(const MetadataPpdResult& other639) { + metadata = other639.metadata; + includeBitset = other639.includeBitset; + __isset = other639.__isset; } -MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other638) { - metadata = other638.metadata; - includeBitset = other638.includeBitset; - __isset = other638.__isset; +MetadataPpdResult& MetadataPpdResult::operator=(const MetadataPpdResult& other640) { + metadata = other640.metadata; + includeBitset = other640.includeBitset; + __isset = other640.__isset; return *this; } void MetadataPpdResult::printTo(std::ostream& out) const { @@ -15995,17 +16131,17 @@ uint32_t GetFileMetadataByExprResult::read(::apache::thrift::protocol::TProtocol if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size639; - ::apache::thrift::protocol::TType _ktype640; - ::apache::thrift::protocol::TType _vtype641; - xfer += iprot->readMapBegin(_ktype640, _vtype641, _size639); - uint32_t _i643; - for (_i643 = 0; _i643 < _size639; ++_i643) + uint32_t _size641; + ::apache::thrift::protocol::TType _ktype642; + ::apache::thrift::protocol::TType _vtype643; + xfer += iprot->readMapBegin(_ktype642, _vtype643, _size641); + uint32_t _i645; + for (_i645 = 0; _i645 < _size641; ++_i645) { - int64_t _key644; - xfer += iprot->readI64(_key644); - MetadataPpdResult& _val645 = this->metadata[_key644]; - xfer += _val645.read(iprot); + int64_t _key646; + xfer += iprot->readI64(_key646); + MetadataPpdResult& _val647 = this->metadata[_key646]; + xfer += _val647.read(iprot); } xfer += iprot->readMapEnd(); } @@ -16046,11 +16182,11 @@ uint32_t GetFileMetadataByExprResult::write(::apache::thrift::protocol::TProtoco xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRUCT, static_cast(this->metadata.size())); - std::map ::const_iterator _iter646; - for (_iter646 = this->metadata.begin(); _iter646 != this->metadata.end(); ++_iter646) + std::map ::const_iterator _iter648; + for (_iter648 = this->metadata.begin(); _iter648 != this->metadata.end(); ++_iter648) { - xfer += oprot->writeI64(_iter646->first); - xfer += _iter646->second.write(oprot); + xfer += oprot->writeI64(_iter648->first); + xfer += _iter648->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -16071,13 +16207,13 @@ void swap(GetFileMetadataByExprResult &a, GetFileMetadataByExprResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other647) { - metadata = other647.metadata; - isSupported = other647.isSupported; +GetFileMetadataByExprResult::GetFileMetadataByExprResult(const GetFileMetadataByExprResult& other649) { + metadata = other649.metadata; + isSupported = other649.isSupported; } -GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other648) { - metadata = other648.metadata; - isSupported = other648.isSupported; +GetFileMetadataByExprResult& GetFileMetadataByExprResult::operator=(const GetFileMetadataByExprResult& other650) { + metadata = other650.metadata; + isSupported = other650.isSupported; return *this; } void GetFileMetadataByExprResult::printTo(std::ostream& out) const { @@ -16138,14 +16274,14 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size649; - ::apache::thrift::protocol::TType _etype652; - xfer += iprot->readListBegin(_etype652, _size649); - this->fileIds.resize(_size649); - uint32_t _i653; - for (_i653 = 0; _i653 < _size649; ++_i653) + uint32_t _size651; + ::apache::thrift::protocol::TType _etype654; + xfer += iprot->readListBegin(_etype654, _size651); + this->fileIds.resize(_size651); + uint32_t _i655; + for (_i655 = 0; _i655 < _size651; ++_i655) { - xfer += iprot->readI64(this->fileIds[_i653]); + xfer += iprot->readI64(this->fileIds[_i655]); } xfer += iprot->readListEnd(); } @@ -16172,9 +16308,9 @@ uint32_t GetFileMetadataByExprRequest::read(::apache::thrift::protocol::TProtoco break; case 4: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast654; - xfer += iprot->readI32(ecast654); - this->type = (FileMetadataExprType::type)ecast654; + int32_t ecast656; + xfer += iprot->readI32(ecast656); + this->type = (FileMetadataExprType::type)ecast656; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16204,10 +16340,10 @@ uint32_t GetFileMetadataByExprRequest::write(::apache::thrift::protocol::TProtoc xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter655; - for (_iter655 = this->fileIds.begin(); _iter655 != this->fileIds.end(); ++_iter655) + std::vector ::const_iterator _iter657; + for (_iter657 = this->fileIds.begin(); _iter657 != this->fileIds.end(); ++_iter657) { - xfer += oprot->writeI64((*_iter655)); + xfer += oprot->writeI64((*_iter657)); } xfer += oprot->writeListEnd(); } @@ -16241,19 +16377,19 @@ void swap(GetFileMetadataByExprRequest &a, GetFileMetadataByExprRequest &b) { swap(a.__isset, b.__isset); } -GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other656) { - fileIds = other656.fileIds; - expr = other656.expr; - doGetFooters = other656.doGetFooters; - type = other656.type; - __isset = other656.__isset; +GetFileMetadataByExprRequest::GetFileMetadataByExprRequest(const GetFileMetadataByExprRequest& other658) { + fileIds = other658.fileIds; + expr = other658.expr; + doGetFooters = other658.doGetFooters; + type = other658.type; + __isset = other658.__isset; } -GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other657) { - fileIds = other657.fileIds; - expr = other657.expr; - doGetFooters = other657.doGetFooters; - type = other657.type; - __isset = other657.__isset; +GetFileMetadataByExprRequest& GetFileMetadataByExprRequest::operator=(const GetFileMetadataByExprRequest& other659) { + fileIds = other659.fileIds; + expr = other659.expr; + doGetFooters = other659.doGetFooters; + type = other659.type; + __isset = other659.__isset; return *this; } void GetFileMetadataByExprRequest::printTo(std::ostream& out) const { @@ -16306,17 +16442,17 @@ uint32_t GetFileMetadataResult::read(::apache::thrift::protocol::TProtocol* ipro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->metadata.clear(); - uint32_t _size658; - ::apache::thrift::protocol::TType _ktype659; - ::apache::thrift::protocol::TType _vtype660; - xfer += iprot->readMapBegin(_ktype659, _vtype660, _size658); - uint32_t _i662; - for (_i662 = 0; _i662 < _size658; ++_i662) + uint32_t _size660; + ::apache::thrift::protocol::TType _ktype661; + ::apache::thrift::protocol::TType _vtype662; + xfer += iprot->readMapBegin(_ktype661, _vtype662, _size660); + uint32_t _i664; + for (_i664 = 0; _i664 < _size660; ++_i664) { - int64_t _key663; - xfer += iprot->readI64(_key663); - std::string& _val664 = this->metadata[_key663]; - xfer += iprot->readBinary(_val664); + int64_t _key665; + xfer += iprot->readI64(_key665); + std::string& _val666 = this->metadata[_key665]; + xfer += iprot->readBinary(_val666); } xfer += iprot->readMapEnd(); } @@ -16357,11 +16493,11 @@ uint32_t GetFileMetadataResult::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_I64, ::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::map ::const_iterator _iter665; - for (_iter665 = this->metadata.begin(); _iter665 != this->metadata.end(); ++_iter665) + std::map ::const_iterator _iter667; + for (_iter667 = this->metadata.begin(); _iter667 != this->metadata.end(); ++_iter667) { - xfer += oprot->writeI64(_iter665->first); - xfer += oprot->writeBinary(_iter665->second); + xfer += oprot->writeI64(_iter667->first); + xfer += oprot->writeBinary(_iter667->second); } xfer += oprot->writeMapEnd(); } @@ -16382,13 +16518,13 @@ void swap(GetFileMetadataResult &a, GetFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other666) { - metadata = other666.metadata; - isSupported = other666.isSupported; +GetFileMetadataResult::GetFileMetadataResult(const GetFileMetadataResult& other668) { + metadata = other668.metadata; + isSupported = other668.isSupported; } -GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other667) { - metadata = other667.metadata; - isSupported = other667.isSupported; +GetFileMetadataResult& GetFileMetadataResult::operator=(const GetFileMetadataResult& other669) { + metadata = other669.metadata; + isSupported = other669.isSupported; return *this; } void GetFileMetadataResult::printTo(std::ostream& out) const { @@ -16434,14 +16570,14 @@ uint32_t GetFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size668; - ::apache::thrift::protocol::TType _etype671; - xfer += iprot->readListBegin(_etype671, _size668); - this->fileIds.resize(_size668); - uint32_t _i672; - for (_i672 = 0; _i672 < _size668; ++_i672) + uint32_t _size670; + ::apache::thrift::protocol::TType _etype673; + xfer += iprot->readListBegin(_etype673, _size670); + this->fileIds.resize(_size670); + uint32_t _i674; + for (_i674 = 0; _i674 < _size670; ++_i674) { - xfer += iprot->readI64(this->fileIds[_i672]); + xfer += iprot->readI64(this->fileIds[_i674]); } xfer += iprot->readListEnd(); } @@ -16472,10 +16608,10 @@ uint32_t GetFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter673; - for (_iter673 = this->fileIds.begin(); _iter673 != this->fileIds.end(); ++_iter673) + std::vector ::const_iterator _iter675; + for (_iter675 = this->fileIds.begin(); _iter675 != this->fileIds.end(); ++_iter675) { - xfer += oprot->writeI64((*_iter673)); + xfer += oprot->writeI64((*_iter675)); } xfer += oprot->writeListEnd(); } @@ -16491,11 +16627,11 @@ void swap(GetFileMetadataRequest &a, GetFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other674) { - fileIds = other674.fileIds; +GetFileMetadataRequest::GetFileMetadataRequest(const GetFileMetadataRequest& other676) { + fileIds = other676.fileIds; } -GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other675) { - fileIds = other675.fileIds; +GetFileMetadataRequest& GetFileMetadataRequest::operator=(const GetFileMetadataRequest& other677) { + fileIds = other677.fileIds; return *this; } void GetFileMetadataRequest::printTo(std::ostream& out) const { @@ -16554,11 +16690,11 @@ void swap(PutFileMetadataResult &a, PutFileMetadataResult &b) { (void) b; } -PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other676) { - (void) other676; +PutFileMetadataResult::PutFileMetadataResult(const PutFileMetadataResult& other678) { + (void) other678; } -PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other677) { - (void) other677; +PutFileMetadataResult& PutFileMetadataResult::operator=(const PutFileMetadataResult& other679) { + (void) other679; return *this; } void PutFileMetadataResult::printTo(std::ostream& out) const { @@ -16612,14 +16748,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size678; - ::apache::thrift::protocol::TType _etype681; - xfer += iprot->readListBegin(_etype681, _size678); - this->fileIds.resize(_size678); - uint32_t _i682; - for (_i682 = 0; _i682 < _size678; ++_i682) + uint32_t _size680; + ::apache::thrift::protocol::TType _etype683; + xfer += iprot->readListBegin(_etype683, _size680); + this->fileIds.resize(_size680); + uint32_t _i684; + for (_i684 = 0; _i684 < _size680; ++_i684) { - xfer += iprot->readI64(this->fileIds[_i682]); + xfer += iprot->readI64(this->fileIds[_i684]); } xfer += iprot->readListEnd(); } @@ -16632,14 +16768,14 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->metadata.clear(); - uint32_t _size683; - ::apache::thrift::protocol::TType _etype686; - xfer += iprot->readListBegin(_etype686, _size683); - this->metadata.resize(_size683); - uint32_t _i687; - for (_i687 = 0; _i687 < _size683; ++_i687) + uint32_t _size685; + ::apache::thrift::protocol::TType _etype688; + xfer += iprot->readListBegin(_etype688, _size685); + this->metadata.resize(_size685); + uint32_t _i689; + for (_i689 = 0; _i689 < _size685; ++_i689) { - xfer += iprot->readBinary(this->metadata[_i687]); + xfer += iprot->readBinary(this->metadata[_i689]); } xfer += iprot->readListEnd(); } @@ -16650,9 +16786,9 @@ uint32_t PutFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* ipr break; case 3: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast688; - xfer += iprot->readI32(ecast688); - this->type = (FileMetadataExprType::type)ecast688; + int32_t ecast690; + xfer += iprot->readI32(ecast690); + this->type = (FileMetadataExprType::type)ecast690; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -16682,10 +16818,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter689; - for (_iter689 = this->fileIds.begin(); _iter689 != this->fileIds.end(); ++_iter689) + std::vector ::const_iterator _iter691; + for (_iter691 = this->fileIds.begin(); _iter691 != this->fileIds.end(); ++_iter691) { - xfer += oprot->writeI64((*_iter689)); + xfer += oprot->writeI64((*_iter691)); } xfer += oprot->writeListEnd(); } @@ -16694,10 +16830,10 @@ uint32_t PutFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* op xfer += oprot->writeFieldBegin("metadata", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast(this->metadata.size())); - std::vector ::const_iterator _iter690; - for (_iter690 = this->metadata.begin(); _iter690 != this->metadata.end(); ++_iter690) + std::vector ::const_iterator _iter692; + for (_iter692 = this->metadata.begin(); _iter692 != this->metadata.end(); ++_iter692) { - xfer += oprot->writeBinary((*_iter690)); + xfer += oprot->writeBinary((*_iter692)); } xfer += oprot->writeListEnd(); } @@ -16721,17 +16857,17 @@ void swap(PutFileMetadataRequest &a, PutFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other691) { - fileIds = other691.fileIds; - metadata = other691.metadata; - type = other691.type; - __isset = other691.__isset; +PutFileMetadataRequest::PutFileMetadataRequest(const PutFileMetadataRequest& other693) { + fileIds = other693.fileIds; + metadata = other693.metadata; + type = other693.type; + __isset = other693.__isset; } -PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other692) { - fileIds = other692.fileIds; - metadata = other692.metadata; - type = other692.type; - __isset = other692.__isset; +PutFileMetadataRequest& PutFileMetadataRequest::operator=(const PutFileMetadataRequest& other694) { + fileIds = other694.fileIds; + metadata = other694.metadata; + type = other694.type; + __isset = other694.__isset; return *this; } void PutFileMetadataRequest::printTo(std::ostream& out) const { @@ -16792,11 +16928,11 @@ void swap(ClearFileMetadataResult &a, ClearFileMetadataResult &b) { (void) b; } -ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other693) { - (void) other693; +ClearFileMetadataResult::ClearFileMetadataResult(const ClearFileMetadataResult& other695) { + (void) other695; } -ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other694) { - (void) other694; +ClearFileMetadataResult& ClearFileMetadataResult::operator=(const ClearFileMetadataResult& other696) { + (void) other696; return *this; } void ClearFileMetadataResult::printTo(std::ostream& out) const { @@ -16840,14 +16976,14 @@ uint32_t ClearFileMetadataRequest::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_LIST) { { this->fileIds.clear(); - uint32_t _size695; - ::apache::thrift::protocol::TType _etype698; - xfer += iprot->readListBegin(_etype698, _size695); - this->fileIds.resize(_size695); - uint32_t _i699; - for (_i699 = 0; _i699 < _size695; ++_i699) + uint32_t _size697; + ::apache::thrift::protocol::TType _etype700; + xfer += iprot->readListBegin(_etype700, _size697); + this->fileIds.resize(_size697); + uint32_t _i701; + for (_i701 = 0; _i701 < _size697; ++_i701) { - xfer += iprot->readI64(this->fileIds[_i699]); + xfer += iprot->readI64(this->fileIds[_i701]); } xfer += iprot->readListEnd(); } @@ -16878,10 +17014,10 @@ uint32_t ClearFileMetadataRequest::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("fileIds", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast(this->fileIds.size())); - std::vector ::const_iterator _iter700; - for (_iter700 = this->fileIds.begin(); _iter700 != this->fileIds.end(); ++_iter700) + std::vector ::const_iterator _iter702; + for (_iter702 = this->fileIds.begin(); _iter702 != this->fileIds.end(); ++_iter702) { - xfer += oprot->writeI64((*_iter700)); + xfer += oprot->writeI64((*_iter702)); } xfer += oprot->writeListEnd(); } @@ -16897,11 +17033,11 @@ void swap(ClearFileMetadataRequest &a, ClearFileMetadataRequest &b) { swap(a.fileIds, b.fileIds); } -ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other701) { - fileIds = other701.fileIds; +ClearFileMetadataRequest::ClearFileMetadataRequest(const ClearFileMetadataRequest& other703) { + fileIds = other703.fileIds; } -ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other702) { - fileIds = other702.fileIds; +ClearFileMetadataRequest& ClearFileMetadataRequest::operator=(const ClearFileMetadataRequest& other704) { + fileIds = other704.fileIds; return *this; } void ClearFileMetadataRequest::printTo(std::ostream& out) const { @@ -16983,11 +17119,11 @@ void swap(CacheFileMetadataResult &a, CacheFileMetadataResult &b) { swap(a.isSupported, b.isSupported); } -CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other703) { - isSupported = other703.isSupported; +CacheFileMetadataResult::CacheFileMetadataResult(const CacheFileMetadataResult& other705) { + isSupported = other705.isSupported; } -CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other704) { - isSupported = other704.isSupported; +CacheFileMetadataResult& CacheFileMetadataResult::operator=(const CacheFileMetadataResult& other706) { + isSupported = other706.isSupported; return *this; } void CacheFileMetadataResult::printTo(std::ostream& out) const { @@ -17128,19 +17264,19 @@ void swap(CacheFileMetadataRequest &a, CacheFileMetadataRequest &b) { swap(a.__isset, b.__isset); } -CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other705) { - dbName = other705.dbName; - tblName = other705.tblName; - partName = other705.partName; - isAllParts = other705.isAllParts; - __isset = other705.__isset; +CacheFileMetadataRequest::CacheFileMetadataRequest(const CacheFileMetadataRequest& other707) { + dbName = other707.dbName; + tblName = other707.tblName; + partName = other707.partName; + isAllParts = other707.isAllParts; + __isset = other707.__isset; } -CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other706) { - dbName = other706.dbName; - tblName = other706.tblName; - partName = other706.partName; - isAllParts = other706.isAllParts; - __isset = other706.__isset; +CacheFileMetadataRequest& CacheFileMetadataRequest::operator=(const CacheFileMetadataRequest& other708) { + dbName = other708.dbName; + tblName = other708.tblName; + partName = other708.partName; + isAllParts = other708.isAllParts; + __isset = other708.__isset; return *this; } void CacheFileMetadataRequest::printTo(std::ostream& out) const { @@ -17188,14 +17324,14 @@ uint32_t GetAllFunctionsResponse::read(::apache::thrift::protocol::TProtocol* ip if (ftype == ::apache::thrift::protocol::T_LIST) { { this->functions.clear(); - uint32_t _size707; - ::apache::thrift::protocol::TType _etype710; - xfer += iprot->readListBegin(_etype710, _size707); - this->functions.resize(_size707); - uint32_t _i711; - for (_i711 = 0; _i711 < _size707; ++_i711) + uint32_t _size709; + ::apache::thrift::protocol::TType _etype712; + xfer += iprot->readListBegin(_etype712, _size709); + this->functions.resize(_size709); + uint32_t _i713; + for (_i713 = 0; _i713 < _size709; ++_i713) { - xfer += this->functions[_i711].read(iprot); + xfer += this->functions[_i713].read(iprot); } xfer += iprot->readListEnd(); } @@ -17225,10 +17361,10 @@ uint32_t GetAllFunctionsResponse::write(::apache::thrift::protocol::TProtocol* o xfer += oprot->writeFieldBegin("functions", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast(this->functions.size())); - std::vector ::const_iterator _iter712; - for (_iter712 = this->functions.begin(); _iter712 != this->functions.end(); ++_iter712) + std::vector ::const_iterator _iter714; + for (_iter714 = this->functions.begin(); _iter714 != this->functions.end(); ++_iter714) { - xfer += (*_iter712).write(oprot); + xfer += (*_iter714).write(oprot); } xfer += oprot->writeListEnd(); } @@ -17245,13 +17381,13 @@ void swap(GetAllFunctionsResponse &a, GetAllFunctionsResponse &b) { swap(a.__isset, b.__isset); } -GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other713) { - functions = other713.functions; - __isset = other713.__isset; +GetAllFunctionsResponse::GetAllFunctionsResponse(const GetAllFunctionsResponse& other715) { + functions = other715.functions; + __isset = other715.__isset; } -GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other714) { - functions = other714.functions; - __isset = other714.__isset; +GetAllFunctionsResponse& GetAllFunctionsResponse::operator=(const GetAllFunctionsResponse& other716) { + functions = other716.functions; + __isset = other716.__isset; return *this; } void GetAllFunctionsResponse::printTo(std::ostream& out) const { @@ -17393,19 +17529,19 @@ void swap(TableMeta &a, TableMeta &b) { swap(a.__isset, b.__isset); } -TableMeta::TableMeta(const TableMeta& other715) { - dbName = other715.dbName; - tableName = other715.tableName; - tableType = other715.tableType; - comments = other715.comments; - __isset = other715.__isset; +TableMeta::TableMeta(const TableMeta& other717) { + dbName = other717.dbName; + tableName = other717.tableName; + tableType = other717.tableType; + comments = other717.comments; + __isset = other717.__isset; } -TableMeta& TableMeta::operator=(const TableMeta& other716) { - dbName = other716.dbName; - tableName = other716.tableName; - tableType = other716.tableType; - comments = other716.comments; - __isset = other716.__isset; +TableMeta& TableMeta::operator=(const TableMeta& other718) { + dbName = other718.dbName; + tableName = other718.tableName; + tableType = other718.tableType; + comments = other718.comments; + __isset = other718.__isset; return *this; } void TableMeta::printTo(std::ostream& out) const { @@ -17488,13 +17624,13 @@ void swap(MetaException &a, MetaException &b) { swap(a.__isset, b.__isset); } -MetaException::MetaException(const MetaException& other717) : TException() { - message = other717.message; - __isset = other717.__isset; +MetaException::MetaException(const MetaException& other719) : TException() { + message = other719.message; + __isset = other719.__isset; } -MetaException& MetaException::operator=(const MetaException& other718) { - message = other718.message; - __isset = other718.__isset; +MetaException& MetaException::operator=(const MetaException& other720) { + message = other720.message; + __isset = other720.__isset; return *this; } void MetaException::printTo(std::ostream& out) const { @@ -17585,13 +17721,13 @@ void swap(UnknownTableException &a, UnknownTableException &b) { swap(a.__isset, b.__isset); } -UnknownTableException::UnknownTableException(const UnknownTableException& other719) : TException() { - message = other719.message; - __isset = other719.__isset; +UnknownTableException::UnknownTableException(const UnknownTableException& other721) : TException() { + message = other721.message; + __isset = other721.__isset; } -UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other720) { - message = other720.message; - __isset = other720.__isset; +UnknownTableException& UnknownTableException::operator=(const UnknownTableException& other722) { + message = other722.message; + __isset = other722.__isset; return *this; } void UnknownTableException::printTo(std::ostream& out) const { @@ -17682,13 +17818,13 @@ void swap(UnknownDBException &a, UnknownDBException &b) { swap(a.__isset, b.__isset); } -UnknownDBException::UnknownDBException(const UnknownDBException& other721) : TException() { - message = other721.message; - __isset = other721.__isset; +UnknownDBException::UnknownDBException(const UnknownDBException& other723) : TException() { + message = other723.message; + __isset = other723.__isset; } -UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other722) { - message = other722.message; - __isset = other722.__isset; +UnknownDBException& UnknownDBException::operator=(const UnknownDBException& other724) { + message = other724.message; + __isset = other724.__isset; return *this; } void UnknownDBException::printTo(std::ostream& out) const { @@ -17779,13 +17915,13 @@ void swap(AlreadyExistsException &a, AlreadyExistsException &b) { swap(a.__isset, b.__isset); } -AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other723) : TException() { - message = other723.message; - __isset = other723.__isset; +AlreadyExistsException::AlreadyExistsException(const AlreadyExistsException& other725) : TException() { + message = other725.message; + __isset = other725.__isset; } -AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other724) { - message = other724.message; - __isset = other724.__isset; +AlreadyExistsException& AlreadyExistsException::operator=(const AlreadyExistsException& other726) { + message = other726.message; + __isset = other726.__isset; return *this; } void AlreadyExistsException::printTo(std::ostream& out) const { @@ -17876,13 +18012,13 @@ void swap(InvalidPartitionException &a, InvalidPartitionException &b) { swap(a.__isset, b.__isset); } -InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other725) : TException() { - message = other725.message; - __isset = other725.__isset; +InvalidPartitionException::InvalidPartitionException(const InvalidPartitionException& other727) : TException() { + message = other727.message; + __isset = other727.__isset; } -InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other726) { - message = other726.message; - __isset = other726.__isset; +InvalidPartitionException& InvalidPartitionException::operator=(const InvalidPartitionException& other728) { + message = other728.message; + __isset = other728.__isset; return *this; } void InvalidPartitionException::printTo(std::ostream& out) const { @@ -17973,13 +18109,13 @@ void swap(UnknownPartitionException &a, UnknownPartitionException &b) { swap(a.__isset, b.__isset); } -UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other727) : TException() { - message = other727.message; - __isset = other727.__isset; +UnknownPartitionException::UnknownPartitionException(const UnknownPartitionException& other729) : TException() { + message = other729.message; + __isset = other729.__isset; } -UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other728) { - message = other728.message; - __isset = other728.__isset; +UnknownPartitionException& UnknownPartitionException::operator=(const UnknownPartitionException& other730) { + message = other730.message; + __isset = other730.__isset; return *this; } void UnknownPartitionException::printTo(std::ostream& out) const { @@ -18070,13 +18206,13 @@ void swap(InvalidObjectException &a, InvalidObjectException &b) { swap(a.__isset, b.__isset); } -InvalidObjectException::InvalidObjectException(const InvalidObjectException& other729) : TException() { - message = other729.message; - __isset = other729.__isset; +InvalidObjectException::InvalidObjectException(const InvalidObjectException& other731) : TException() { + message = other731.message; + __isset = other731.__isset; } -InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other730) { - message = other730.message; - __isset = other730.__isset; +InvalidObjectException& InvalidObjectException::operator=(const InvalidObjectException& other732) { + message = other732.message; + __isset = other732.__isset; return *this; } void InvalidObjectException::printTo(std::ostream& out) const { @@ -18167,13 +18303,13 @@ void swap(NoSuchObjectException &a, NoSuchObjectException &b) { swap(a.__isset, b.__isset); } -NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other731) : TException() { - message = other731.message; - __isset = other731.__isset; +NoSuchObjectException::NoSuchObjectException(const NoSuchObjectException& other733) : TException() { + message = other733.message; + __isset = other733.__isset; } -NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other732) { - message = other732.message; - __isset = other732.__isset; +NoSuchObjectException& NoSuchObjectException::operator=(const NoSuchObjectException& other734) { + message = other734.message; + __isset = other734.__isset; return *this; } void NoSuchObjectException::printTo(std::ostream& out) const { @@ -18264,13 +18400,13 @@ void swap(IndexAlreadyExistsException &a, IndexAlreadyExistsException &b) { swap(a.__isset, b.__isset); } -IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other733) : TException() { - message = other733.message; - __isset = other733.__isset; +IndexAlreadyExistsException::IndexAlreadyExistsException(const IndexAlreadyExistsException& other735) : TException() { + message = other735.message; + __isset = other735.__isset; } -IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other734) { - message = other734.message; - __isset = other734.__isset; +IndexAlreadyExistsException& IndexAlreadyExistsException::operator=(const IndexAlreadyExistsException& other736) { + message = other736.message; + __isset = other736.__isset; return *this; } void IndexAlreadyExistsException::printTo(std::ostream& out) const { @@ -18361,13 +18497,13 @@ void swap(InvalidOperationException &a, InvalidOperationException &b) { swap(a.__isset, b.__isset); } -InvalidOperationException::InvalidOperationException(const InvalidOperationException& other735) : TException() { - message = other735.message; - __isset = other735.__isset; +InvalidOperationException::InvalidOperationException(const InvalidOperationException& other737) : TException() { + message = other737.message; + __isset = other737.__isset; } -InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other736) { - message = other736.message; - __isset = other736.__isset; +InvalidOperationException& InvalidOperationException::operator=(const InvalidOperationException& other738) { + message = other738.message; + __isset = other738.__isset; return *this; } void InvalidOperationException::printTo(std::ostream& out) const { @@ -18458,13 +18594,13 @@ void swap(ConfigValSecurityException &a, ConfigValSecurityException &b) { swap(a.__isset, b.__isset); } -ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other737) : TException() { - message = other737.message; - __isset = other737.__isset; +ConfigValSecurityException::ConfigValSecurityException(const ConfigValSecurityException& other739) : TException() { + message = other739.message; + __isset = other739.__isset; } -ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other738) { - message = other738.message; - __isset = other738.__isset; +ConfigValSecurityException& ConfigValSecurityException::operator=(const ConfigValSecurityException& other740) { + message = other740.message; + __isset = other740.__isset; return *this; } void ConfigValSecurityException::printTo(std::ostream& out) const { @@ -18555,13 +18691,13 @@ void swap(InvalidInputException &a, InvalidInputException &b) { swap(a.__isset, b.__isset); } -InvalidInputException::InvalidInputException(const InvalidInputException& other739) : TException() { - message = other739.message; - __isset = other739.__isset; +InvalidInputException::InvalidInputException(const InvalidInputException& other741) : TException() { + message = other741.message; + __isset = other741.__isset; } -InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other740) { - message = other740.message; - __isset = other740.__isset; +InvalidInputException& InvalidInputException::operator=(const InvalidInputException& other742) { + message = other742.message; + __isset = other742.__isset; return *this; } void InvalidInputException::printTo(std::ostream& out) const { @@ -18652,13 +18788,13 @@ void swap(NoSuchTxnException &a, NoSuchTxnException &b) { swap(a.__isset, b.__isset); } -NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other741) : TException() { - message = other741.message; - __isset = other741.__isset; +NoSuchTxnException::NoSuchTxnException(const NoSuchTxnException& other743) : TException() { + message = other743.message; + __isset = other743.__isset; } -NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other742) { - message = other742.message; - __isset = other742.__isset; +NoSuchTxnException& NoSuchTxnException::operator=(const NoSuchTxnException& other744) { + message = other744.message; + __isset = other744.__isset; return *this; } void NoSuchTxnException::printTo(std::ostream& out) const { @@ -18749,13 +18885,13 @@ void swap(TxnAbortedException &a, TxnAbortedException &b) { swap(a.__isset, b.__isset); } -TxnAbortedException::TxnAbortedException(const TxnAbortedException& other743) : TException() { - message = other743.message; - __isset = other743.__isset; +TxnAbortedException::TxnAbortedException(const TxnAbortedException& other745) : TException() { + message = other745.message; + __isset = other745.__isset; } -TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other744) { - message = other744.message; - __isset = other744.__isset; +TxnAbortedException& TxnAbortedException::operator=(const TxnAbortedException& other746) { + message = other746.message; + __isset = other746.__isset; return *this; } void TxnAbortedException::printTo(std::ostream& out) const { @@ -18846,13 +18982,13 @@ void swap(TxnOpenException &a, TxnOpenException &b) { swap(a.__isset, b.__isset); } -TxnOpenException::TxnOpenException(const TxnOpenException& other745) : TException() { - message = other745.message; - __isset = other745.__isset; +TxnOpenException::TxnOpenException(const TxnOpenException& other747) : TException() { + message = other747.message; + __isset = other747.__isset; } -TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other746) { - message = other746.message; - __isset = other746.__isset; +TxnOpenException& TxnOpenException::operator=(const TxnOpenException& other748) { + message = other748.message; + __isset = other748.__isset; return *this; } void TxnOpenException::printTo(std::ostream& out) const { @@ -18943,13 +19079,13 @@ void swap(NoSuchLockException &a, NoSuchLockException &b) { swap(a.__isset, b.__isset); } -NoSuchLockException::NoSuchLockException(const NoSuchLockException& other747) : TException() { - message = other747.message; - __isset = other747.__isset; +NoSuchLockException::NoSuchLockException(const NoSuchLockException& other749) : TException() { + message = other749.message; + __isset = other749.__isset; } -NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other748) { - message = other748.message; - __isset = other748.__isset; +NoSuchLockException& NoSuchLockException::operator=(const NoSuchLockException& other750) { + message = other750.message; + __isset = other750.__isset; return *this; } void NoSuchLockException::printTo(std::ostream& out) const { diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h index d392f67..74b74ac 100644 --- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h +++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h @@ -239,6 +239,8 @@ class AggrStats; class SetPartitionsStatsRequest; +class SetColumnStatsRequest; + class Schema; class EnvironmentContext; @@ -3460,24 +3462,37 @@ inline std::ostream& operator<<(std::ostream& out, const AggrStats& obj) return out; } +typedef struct _SetPartitionsStatsRequest__isset { + _SetPartitionsStatsRequest__isset() : numBitVector(false) {} + bool numBitVector :1; +} _SetPartitionsStatsRequest__isset; class SetPartitionsStatsRequest { public: SetPartitionsStatsRequest(const SetPartitionsStatsRequest&); SetPartitionsStatsRequest& operator=(const SetPartitionsStatsRequest&); - SetPartitionsStatsRequest() { + SetPartitionsStatsRequest() : numBitVector(0) { } virtual ~SetPartitionsStatsRequest() throw(); std::vector colStats; + int32_t numBitVector; + + _SetPartitionsStatsRequest__isset __isset; void __set_colStats(const std::vector & val); + void __set_numBitVector(const int32_t val); + bool operator == (const SetPartitionsStatsRequest & rhs) const { if (!(colStats == rhs.colStats)) return false; + if (__isset.numBitVector != rhs.__isset.numBitVector) + return false; + else if (__isset.numBitVector && !(numBitVector == rhs.numBitVector)) + return false; return true; } bool operator != (const SetPartitionsStatsRequest &rhs) const { @@ -3500,6 +3515,59 @@ inline std::ostream& operator<<(std::ostream& out, const SetPartitionsStatsReque return out; } +typedef struct _SetColumnStatsRequest__isset { + _SetColumnStatsRequest__isset() : numBitVector(false) {} + bool numBitVector :1; +} _SetColumnStatsRequest__isset; + +class SetColumnStatsRequest { + public: + + SetColumnStatsRequest(const SetColumnStatsRequest&); + SetColumnStatsRequest& operator=(const SetColumnStatsRequest&); + SetColumnStatsRequest() : numBitVector(0) { + } + + virtual ~SetColumnStatsRequest() throw(); + ColumnStatistics colStats; + int32_t numBitVector; + + _SetColumnStatsRequest__isset __isset; + + void __set_colStats(const ColumnStatistics& val); + + void __set_numBitVector(const int32_t val); + + bool operator == (const SetColumnStatsRequest & rhs) const + { + if (!(colStats == rhs.colStats)) + return false; + if (__isset.numBitVector != rhs.__isset.numBitVector) + return false; + else if (__isset.numBitVector && !(numBitVector == rhs.numBitVector)) + return false; + return true; + } + bool operator != (const SetColumnStatsRequest &rhs) const { + return !(*this == rhs); + } + + bool operator < (const SetColumnStatsRequest & ) const; + + uint32_t read(::apache::thrift::protocol::TProtocol* iprot); + uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; + + virtual void printTo(std::ostream& out) const; +}; + +void swap(SetColumnStatsRequest &a, SetColumnStatsRequest &b); + +inline std::ostream& operator<<(std::ostream& out, const SetColumnStatsRequest& obj) +{ + obj.printTo(out); + return out; +} + typedef struct _Schema__isset { _Schema__isset() : fieldSchemas(false), properties(false) {} bool fieldSchemas :1; diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetColumnStatsRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetColumnStatsRequest.java new file mode 100644 index 0000000..15d6e08 --- /dev/null +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetColumnStatsRequest.java @@ -0,0 +1,501 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hive.metastore.api; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)") +public class SetColumnStatsRequest implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("SetColumnStatsRequest"); + + private static final org.apache.thrift.protocol.TField COL_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("colStats", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField NUM_BIT_VECTOR_FIELD_DESC = new org.apache.thrift.protocol.TField("numBitVector", org.apache.thrift.protocol.TType.I32, (short)2); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new SetColumnStatsRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new SetColumnStatsRequestTupleSchemeFactory()); + } + + private ColumnStatistics colStats; // required + private int numBitVector; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + COL_STATS((short)1, "colStats"), + NUM_BIT_VECTOR((short)2, "numBitVector"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // COL_STATS + return COL_STATS; + case 2: // NUM_BIT_VECTOR + return NUM_BIT_VECTOR; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __NUMBITVECTOR_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.NUM_BIT_VECTOR}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.COL_STATS, new org.apache.thrift.meta_data.FieldMetaData("colStats", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatistics.class))); + tmpMap.put(_Fields.NUM_BIT_VECTOR, new org.apache.thrift.meta_data.FieldMetaData("numBitVector", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(SetColumnStatsRequest.class, metaDataMap); + } + + public SetColumnStatsRequest() { + } + + public SetColumnStatsRequest( + ColumnStatistics colStats) + { + this(); + this.colStats = colStats; + } + + /** + * Performs a deep copy on other. + */ + public SetColumnStatsRequest(SetColumnStatsRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetColStats()) { + this.colStats = new ColumnStatistics(other.colStats); + } + this.numBitVector = other.numBitVector; + } + + public SetColumnStatsRequest deepCopy() { + return new SetColumnStatsRequest(this); + } + + @Override + public void clear() { + this.colStats = null; + setNumBitVectorIsSet(false); + this.numBitVector = 0; + } + + public ColumnStatistics getColStats() { + return this.colStats; + } + + public void setColStats(ColumnStatistics colStats) { + this.colStats = colStats; + } + + public void unsetColStats() { + this.colStats = null; + } + + /** Returns true if field colStats is set (has been assigned a value) and false otherwise */ + public boolean isSetColStats() { + return this.colStats != null; + } + + public void setColStatsIsSet(boolean value) { + if (!value) { + this.colStats = null; + } + } + + public int getNumBitVector() { + return this.numBitVector; + } + + public void setNumBitVector(int numBitVector) { + this.numBitVector = numBitVector; + setNumBitVectorIsSet(true); + } + + public void unsetNumBitVector() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID); + } + + /** Returns true if field numBitVector is set (has been assigned a value) and false otherwise */ + public boolean isSetNumBitVector() { + return EncodingUtils.testBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID); + } + + public void setNumBitVectorIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case COL_STATS: + if (value == null) { + unsetColStats(); + } else { + setColStats((ColumnStatistics)value); + } + break; + + case NUM_BIT_VECTOR: + if (value == null) { + unsetNumBitVector(); + } else { + setNumBitVector((Integer)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case COL_STATS: + return getColStats(); + + case NUM_BIT_VECTOR: + return getNumBitVector(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case COL_STATS: + return isSetColStats(); + case NUM_BIT_VECTOR: + return isSetNumBitVector(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof SetColumnStatsRequest) + return this.equals((SetColumnStatsRequest)that); + return false; + } + + public boolean equals(SetColumnStatsRequest that) { + if (that == null) + return false; + + boolean this_present_colStats = true && this.isSetColStats(); + boolean that_present_colStats = true && that.isSetColStats(); + if (this_present_colStats || that_present_colStats) { + if (!(this_present_colStats && that_present_colStats)) + return false; + if (!this.colStats.equals(that.colStats)) + return false; + } + + boolean this_present_numBitVector = true && this.isSetNumBitVector(); + boolean that_present_numBitVector = true && that.isSetNumBitVector(); + if (this_present_numBitVector || that_present_numBitVector) { + if (!(this_present_numBitVector && that_present_numBitVector)) + return false; + if (this.numBitVector != that.numBitVector) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_colStats = true && (isSetColStats()); + list.add(present_colStats); + if (present_colStats) + list.add(colStats); + + boolean present_numBitVector = true && (isSetNumBitVector()); + list.add(present_numBitVector); + if (present_numBitVector) + list.add(numBitVector); + + return list.hashCode(); + } + + @Override + public int compareTo(SetColumnStatsRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetColStats()).compareTo(other.isSetColStats()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetColStats()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colStats, other.colStats); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetNumBitVector()).compareTo(other.isSetNumBitVector()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNumBitVector()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numBitVector, other.numBitVector); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("SetColumnStatsRequest("); + boolean first = true; + + sb.append("colStats:"); + if (this.colStats == null) { + sb.append("null"); + } else { + sb.append(this.colStats); + } + first = false; + if (isSetNumBitVector()) { + if (!first) sb.append(", "); + sb.append("numBitVector:"); + sb.append(this.numBitVector); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetColStats()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'colStats' is unset! Struct:" + toString()); + } + + // check for sub-struct validity + if (colStats != null) { + colStats.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class SetColumnStatsRequestStandardSchemeFactory implements SchemeFactory { + public SetColumnStatsRequestStandardScheme getScheme() { + return new SetColumnStatsRequestStandardScheme(); + } + } + + private static class SetColumnStatsRequestStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, SetColumnStatsRequest struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // COL_STATS + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.colStats = new ColumnStatistics(); + struct.colStats.read(iprot); + struct.setColStatsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // NUM_BIT_VECTOR + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.numBitVector = iprot.readI32(); + struct.setNumBitVectorIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, SetColumnStatsRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.colStats != null) { + oprot.writeFieldBegin(COL_STATS_FIELD_DESC); + struct.colStats.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.isSetNumBitVector()) { + oprot.writeFieldBegin(NUM_BIT_VECTOR_FIELD_DESC); + oprot.writeI32(struct.numBitVector); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class SetColumnStatsRequestTupleSchemeFactory implements SchemeFactory { + public SetColumnStatsRequestTupleScheme getScheme() { + return new SetColumnStatsRequestTupleScheme(); + } + } + + private static class SetColumnStatsRequestTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, SetColumnStatsRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + struct.colStats.write(oprot); + BitSet optionals = new BitSet(); + if (struct.isSetNumBitVector()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetNumBitVector()) { + oprot.writeI32(struct.numBitVector); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, SetColumnStatsRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.colStats = new ColumnStatistics(); + struct.colStats.read(iprot); + struct.setColStatsIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.numBitVector = iprot.readI32(); + struct.setNumBitVectorIsSet(true); + } + } + } + +} + diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetPartitionsStatsRequest.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetPartitionsStatsRequest.java index 6e334f6..54eb744 100644 --- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetPartitionsStatsRequest.java +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/SetPartitionsStatsRequest.java @@ -39,6 +39,7 @@ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("SetPartitionsStatsRequest"); private static final org.apache.thrift.protocol.TField COL_STATS_FIELD_DESC = new org.apache.thrift.protocol.TField("colStats", org.apache.thrift.protocol.TType.LIST, (short)1); + private static final org.apache.thrift.protocol.TField NUM_BIT_VECTOR_FIELD_DESC = new org.apache.thrift.protocol.TField("numBitVector", org.apache.thrift.protocol.TType.I32, (short)2); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { @@ -47,10 +48,12 @@ } private List colStats; // required + private int numBitVector; // optional /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - COL_STATS((short)1, "colStats"); + COL_STATS((short)1, "colStats"), + NUM_BIT_VECTOR((short)2, "numBitVector"); private static final Map byName = new HashMap(); @@ -67,6 +70,8 @@ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { case 1: // COL_STATS return COL_STATS; + case 2: // NUM_BIT_VECTOR + return NUM_BIT_VECTOR; default: return null; } @@ -107,12 +112,17 @@ public String getFieldName() { } // isset id assignments + private static final int __NUMBITVECTOR_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.NUM_BIT_VECTOR}; public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); tmpMap.put(_Fields.COL_STATS, new org.apache.thrift.meta_data.FieldMetaData("colStats", org.apache.thrift.TFieldRequirementType.REQUIRED, new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatistics.class)))); + tmpMap.put(_Fields.NUM_BIT_VECTOR, new org.apache.thrift.meta_data.FieldMetaData("numBitVector", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); metaDataMap = Collections.unmodifiableMap(tmpMap); org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(SetPartitionsStatsRequest.class, metaDataMap); } @@ -131,6 +141,7 @@ public SetPartitionsStatsRequest( * Performs a deep copy on other. */ public SetPartitionsStatsRequest(SetPartitionsStatsRequest other) { + __isset_bitfield = other.__isset_bitfield; if (other.isSetColStats()) { List __this__colStats = new ArrayList(other.colStats.size()); for (ColumnStatistics other_element : other.colStats) { @@ -138,6 +149,7 @@ public SetPartitionsStatsRequest(SetPartitionsStatsRequest other) { } this.colStats = __this__colStats; } + this.numBitVector = other.numBitVector; } public SetPartitionsStatsRequest deepCopy() { @@ -147,6 +159,8 @@ public SetPartitionsStatsRequest deepCopy() { @Override public void clear() { this.colStats = null; + setNumBitVectorIsSet(false); + this.numBitVector = 0; } public int getColStatsSize() { @@ -187,6 +201,28 @@ public void setColStatsIsSet(boolean value) { } } + public int getNumBitVector() { + return this.numBitVector; + } + + public void setNumBitVector(int numBitVector) { + this.numBitVector = numBitVector; + setNumBitVectorIsSet(true); + } + + public void unsetNumBitVector() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID); + } + + /** Returns true if field numBitVector is set (has been assigned a value) and false otherwise */ + public boolean isSetNumBitVector() { + return EncodingUtils.testBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID); + } + + public void setNumBitVectorIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __NUMBITVECTOR_ISSET_ID, value); + } + public void setFieldValue(_Fields field, Object value) { switch (field) { case COL_STATS: @@ -197,6 +233,14 @@ public void setFieldValue(_Fields field, Object value) { } break; + case NUM_BIT_VECTOR: + if (value == null) { + unsetNumBitVector(); + } else { + setNumBitVector((Integer)value); + } + break; + } } @@ -205,6 +249,9 @@ public Object getFieldValue(_Fields field) { case COL_STATS: return getColStats(); + case NUM_BIT_VECTOR: + return getNumBitVector(); + } throw new IllegalStateException(); } @@ -218,6 +265,8 @@ public boolean isSet(_Fields field) { switch (field) { case COL_STATS: return isSetColStats(); + case NUM_BIT_VECTOR: + return isSetNumBitVector(); } throw new IllegalStateException(); } @@ -244,6 +293,15 @@ public boolean equals(SetPartitionsStatsRequest that) { return false; } + boolean this_present_numBitVector = true && this.isSetNumBitVector(); + boolean that_present_numBitVector = true && that.isSetNumBitVector(); + if (this_present_numBitVector || that_present_numBitVector) { + if (!(this_present_numBitVector && that_present_numBitVector)) + return false; + if (this.numBitVector != that.numBitVector) + return false; + } + return true; } @@ -256,6 +314,11 @@ public int hashCode() { if (present_colStats) list.add(colStats); + boolean present_numBitVector = true && (isSetNumBitVector()); + list.add(present_numBitVector); + if (present_numBitVector) + list.add(numBitVector); + return list.hashCode(); } @@ -277,6 +340,16 @@ public int compareTo(SetPartitionsStatsRequest other) { return lastComparison; } } + lastComparison = Boolean.valueOf(isSetNumBitVector()).compareTo(other.isSetNumBitVector()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetNumBitVector()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.numBitVector, other.numBitVector); + if (lastComparison != 0) { + return lastComparison; + } + } return 0; } @@ -304,6 +377,12 @@ public String toString() { sb.append(this.colStats); } first = false; + if (isSetNumBitVector()) { + if (!first) sb.append(", "); + sb.append("numBitVector:"); + sb.append(this.numBitVector); + first = false; + } sb.append(")"); return sb.toString(); } @@ -327,6 +406,8 @@ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOExcept private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); @@ -370,6 +451,14 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, SetPartitionsStatsR org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } break; + case 2: // NUM_BIT_VECTOR + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.numBitVector = iprot.readI32(); + struct.setNumBitVectorIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; default: org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -395,6 +484,11 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, SetPartitionsStats } oprot.writeFieldEnd(); } + if (struct.isSetNumBitVector()) { + oprot.writeFieldBegin(NUM_BIT_VECTOR_FIELD_DESC); + oprot.writeI32(struct.numBitVector); + oprot.writeFieldEnd(); + } oprot.writeFieldStop(); oprot.writeStructEnd(); } @@ -419,6 +513,14 @@ public void write(org.apache.thrift.protocol.TProtocol prot, SetPartitionsStatsR _iter290.write(oprot); } } + BitSet optionals = new BitSet(); + if (struct.isSetNumBitVector()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetNumBitVector()) { + oprot.writeI32(struct.numBitVector); + } } @Override @@ -436,6 +538,11 @@ public void read(org.apache.thrift.protocol.TProtocol prot, SetPartitionsStatsRe } } struct.setColStatsIsSet(true); + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.numBitVector = iprot.readI32(); + struct.setNumBitVectorIsSet(true); + } } } diff --git a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java index 051c1f2..5661b10 100644 --- a/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java +++ b/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java @@ -206,6 +206,8 @@ public boolean update_partition_column_statistics(ColumnStatistics stats_obj) throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, org.apache.thrift.TException; + public boolean renew_column_statistics(SetColumnStatsRequest request) throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, org.apache.thrift.TException; + public ColumnStatistics get_table_column_statistics(String db_name, String tbl_name, String col_name) throws NoSuchObjectException, MetaException, InvalidInputException, InvalidObjectException, org.apache.thrift.TException; public ColumnStatistics get_partition_column_statistics(String db_name, String tbl_name, String part_name, String col_name) throws NoSuchObjectException, MetaException, InvalidInputException, InvalidObjectException, org.apache.thrift.TException; @@ -502,6 +504,8 @@ public void update_partition_column_statistics(ColumnStatistics stats_obj, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void renew_column_statistics(SetColumnStatsRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; + public void get_table_column_statistics(String db_name, String tbl_name, String col_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; public void get_partition_column_statistics(String db_name, String tbl_name, String part_name, String col_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; @@ -3192,6 +3196,41 @@ public boolean recv_update_partition_column_statistics() throws NoSuchObjectExce throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "update_partition_column_statistics failed: unknown result"); } + public boolean renew_column_statistics(SetColumnStatsRequest request) throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, org.apache.thrift.TException + { + send_renew_column_statistics(request); + return recv_renew_column_statistics(); + } + + public void send_renew_column_statistics(SetColumnStatsRequest request) throws org.apache.thrift.TException + { + renew_column_statistics_args args = new renew_column_statistics_args(); + args.setRequest(request); + sendBase("renew_column_statistics", args); + } + + public boolean recv_renew_column_statistics() throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, org.apache.thrift.TException + { + renew_column_statistics_result result = new renew_column_statistics_result(); + receiveBase(result, "renew_column_statistics"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.o1 != null) { + throw result.o1; + } + if (result.o2 != null) { + throw result.o2; + } + if (result.o3 != null) { + throw result.o3; + } + if (result.o4 != null) { + throw result.o4; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "renew_column_statistics failed: unknown result"); + } + public ColumnStatistics get_table_column_statistics(String db_name, String tbl_name, String col_name) throws NoSuchObjectException, MetaException, InvalidInputException, InvalidObjectException, org.apache.thrift.TException { send_get_table_column_statistics(db_name, tbl_name, col_name); @@ -7929,6 +7968,38 @@ public boolean getResult() throws NoSuchObjectException, InvalidObjectException, } } + public void renew_column_statistics(SetColumnStatsRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + renew_column_statistics_call method_call = new renew_column_statistics_call(request, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class renew_column_statistics_call extends org.apache.thrift.async.TAsyncMethodCall { + private SetColumnStatsRequest request; + public renew_column_statistics_call(SetColumnStatsRequest request, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.request = request; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("renew_column_statistics", org.apache.thrift.protocol.TMessageType.CALL, 0)); + renew_column_statistics_args args = new renew_column_statistics_args(); + args.setRequest(request); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_renew_column_statistics(); + } + } + public void get_table_column_statistics(String db_name, String tbl_name, String col_name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { checkReady(); get_table_column_statistics_call method_call = new get_table_column_statistics_call(db_name, tbl_name, col_name, resultHandler, this, ___protocolFactory, ___transport); @@ -10141,6 +10212,7 @@ protected Processor(I iface, Map extends org.apache.thrift.ProcessFunction { + public renew_column_statistics() { + super("renew_column_statistics"); + } + + public renew_column_statistics_args getEmptyArgsInstance() { + return new renew_column_statistics_args(); + } + + protected boolean isOneway() { + return false; + } + + public renew_column_statistics_result getResult(I iface, renew_column_statistics_args args) throws org.apache.thrift.TException { + renew_column_statistics_result result = new renew_column_statistics_result(); + try { + result.success = iface.renew_column_statistics(args.request); + result.setSuccessIsSet(true); + } catch (NoSuchObjectException o1) { + result.o1 = o1; + } catch (InvalidObjectException o2) { + result.o2 = o2; + } catch (MetaException o3) { + result.o3 = o3; + } catch (InvalidInputException o4) { + result.o4 = o4; + } + return result; + } + } + public static class get_table_column_statistics extends org.apache.thrift.ProcessFunction { public get_table_column_statistics() { super("get_table_column_statistics"); @@ -14027,6 +14130,7 @@ protected AsyncProcessor(I iface, Map extends org.apache.thrift.AsyncProcessFunction { - public get_table_column_statistics() { - super("get_table_column_statistics"); + public static class renew_column_statistics extends org.apache.thrift.AsyncProcessFunction { + public renew_column_statistics() { + super("renew_column_statistics"); } - public get_table_column_statistics_args getEmptyArgsInstance() { - return new get_table_column_statistics_args(); + public renew_column_statistics_args getEmptyArgsInstance() { + return new renew_column_statistics_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(ColumnStatistics o) { - get_table_column_statistics_result result = new get_table_column_statistics_result(); + return new AsyncMethodCallback() { + public void onComplete(Boolean o) { + renew_column_statistics_result result = new renew_column_statistics_result(); result.success = o; + result.setSuccessIsSet(true); try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); return; @@ -19334,24 +19439,24 @@ public void onComplete(ColumnStatistics o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_table_column_statistics_result result = new get_table_column_statistics_result(); + renew_column_statistics_result result = new renew_column_statistics_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); msg = result; } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; + else if (e instanceof InvalidObjectException) { + result.o2 = (InvalidObjectException) e; result.setO2IsSet(true); msg = result; } - else if (e instanceof InvalidInputException) { - result.o3 = (InvalidInputException) e; + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; result.setO3IsSet(true); msg = result; } - else if (e instanceof InvalidObjectException) { - result.o4 = (InvalidObjectException) e; + else if (e instanceof InvalidInputException) { + result.o4 = (InvalidInputException) e; result.setO4IsSet(true); msg = result; } @@ -19375,25 +19480,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_table_column_statistics_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_table_column_statistics(args.db_name, args.tbl_name, args.col_name,resultHandler); + public void start(I iface, renew_column_statistics_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.renew_column_statistics(args.request,resultHandler); } } - public static class get_partition_column_statistics extends org.apache.thrift.AsyncProcessFunction { - public get_partition_column_statistics() { - super("get_partition_column_statistics"); + public static class get_table_column_statistics extends org.apache.thrift.AsyncProcessFunction { + public get_table_column_statistics() { + super("get_table_column_statistics"); } - public get_partition_column_statistics_args getEmptyArgsInstance() { - return new get_partition_column_statistics_args(); + public get_table_column_statistics_args getEmptyArgsInstance() { + return new get_table_column_statistics_args(); } public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; return new AsyncMethodCallback() { public void onComplete(ColumnStatistics o) { - get_partition_column_statistics_result result = new get_partition_column_statistics_result(); + get_table_column_statistics_result result = new get_table_column_statistics_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -19406,7 +19511,7 @@ public void onComplete(ColumnStatistics o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_partition_column_statistics_result result = new get_partition_column_statistics_result(); + get_table_column_statistics_result result = new get_table_column_statistics_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -19447,149 +19552,25 @@ protected boolean isOneway() { return false; } - public void start(I iface, get_partition_column_statistics_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_partition_column_statistics(args.db_name, args.tbl_name, args.part_name, args.col_name,resultHandler); - } - } - - public static class get_table_statistics_req extends org.apache.thrift.AsyncProcessFunction { - public get_table_statistics_req() { - super("get_table_statistics_req"); - } - - public get_table_statistics_req_args getEmptyArgsInstance() { - return new get_table_statistics_req_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(TableStatsResult o) { - get_table_statistics_req_result result = new get_table_statistics_req_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_table_statistics_req_result result = new get_table_statistics_req_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_table_statistics_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_table_statistics_req(args.request,resultHandler); - } - } - - public static class get_partitions_statistics_req extends org.apache.thrift.AsyncProcessFunction { - public get_partitions_statistics_req() { - super("get_partitions_statistics_req"); - } - - public get_partitions_statistics_req_args getEmptyArgsInstance() { - return new get_partitions_statistics_req_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(PartitionsStatsResult o) { - get_partitions_statistics_req_result result = new get_partitions_statistics_req_result(); - result.success = o; - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - get_partitions_statistics_req_result result = new get_partitions_statistics_req_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof MetaException) { - result.o2 = (MetaException) e; - result.setO2IsSet(true); - msg = result; - } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_partitions_statistics_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_partitions_statistics_req(args.request,resultHandler); + public void start(I iface, get_table_column_statistics_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_table_column_statistics(args.db_name, args.tbl_name, args.col_name,resultHandler); } } - public static class get_aggr_stats_for extends org.apache.thrift.AsyncProcessFunction { - public get_aggr_stats_for() { - super("get_aggr_stats_for"); + public static class get_partition_column_statistics extends org.apache.thrift.AsyncProcessFunction { + public get_partition_column_statistics() { + super("get_partition_column_statistics"); } - public get_aggr_stats_for_args getEmptyArgsInstance() { - return new get_aggr_stats_for_args(); + public get_partition_column_statistics_args getEmptyArgsInstance() { + return new get_partition_column_statistics_args(); } - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(AggrStats o) { - get_aggr_stats_for_result result = new get_aggr_stats_for_result(); + return new AsyncMethodCallback() { + public void onComplete(ColumnStatistics o) { + get_partition_column_statistics_result result = new get_partition_column_statistics_result(); result.success = o; try { fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); @@ -19602,7 +19583,7 @@ public void onComplete(AggrStats o) { public void onError(Exception e) { byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; org.apache.thrift.TBase msg; - get_aggr_stats_for_result result = new get_aggr_stats_for_result(); + get_partition_column_statistics_result result = new get_partition_column_statistics_result(); if (e instanceof NoSuchObjectException) { result.o1 = (NoSuchObjectException) e; result.setO1IsSet(true); @@ -19613,76 +19594,272 @@ else if (e instanceof MetaException) { result.setO2IsSet(true); msg = result; } - else - { - msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; - msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); - } - try { - fcall.sendResponse(fb,msg,msgType,seqid); - return; - } catch (Exception ex) { - LOGGER.error("Exception writing to internal frame buffer", ex); - } - fb.close(); - } - }; - } - - protected boolean isOneway() { - return false; - } - - public void start(I iface, get_aggr_stats_for_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { - iface.get_aggr_stats_for(args.request,resultHandler); - } - } - - public static class set_aggr_stats_for extends org.apache.thrift.AsyncProcessFunction { - public set_aggr_stats_for() { - super("set_aggr_stats_for"); - } - - public set_aggr_stats_for_args getEmptyArgsInstance() { - return new set_aggr_stats_for_args(); - } - - public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { - final org.apache.thrift.AsyncProcessFunction fcall = this; - return new AsyncMethodCallback() { - public void onComplete(Boolean o) { - set_aggr_stats_for_result result = new set_aggr_stats_for_result(); - result.success = o; - result.setSuccessIsSet(true); - try { - fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); - return; - } catch (Exception e) { - LOGGER.error("Exception writing to internal frame buffer", e); - } - fb.close(); - } - public void onError(Exception e) { - byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; - org.apache.thrift.TBase msg; - set_aggr_stats_for_result result = new set_aggr_stats_for_result(); - if (e instanceof NoSuchObjectException) { - result.o1 = (NoSuchObjectException) e; - result.setO1IsSet(true); - msg = result; - } - else if (e instanceof InvalidObjectException) { - result.o2 = (InvalidObjectException) e; - result.setO2IsSet(true); - msg = result; - } - else if (e instanceof MetaException) { - result.o3 = (MetaException) e; + else if (e instanceof InvalidInputException) { + result.o3 = (InvalidInputException) e; result.setO3IsSet(true); msg = result; } - else if (e instanceof InvalidInputException) { - result.o4 = (InvalidInputException) e; + else if (e instanceof InvalidObjectException) { + result.o4 = (InvalidObjectException) e; + result.setO4IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_partition_column_statistics_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_partition_column_statistics(args.db_name, args.tbl_name, args.part_name, args.col_name,resultHandler); + } + } + + public static class get_table_statistics_req extends org.apache.thrift.AsyncProcessFunction { + public get_table_statistics_req() { + super("get_table_statistics_req"); + } + + public get_table_statistics_req_args getEmptyArgsInstance() { + return new get_table_statistics_req_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(TableStatsResult o) { + get_table_statistics_req_result result = new get_table_statistics_req_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + get_table_statistics_req_result result = new get_table_statistics_req_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_table_statistics_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_table_statistics_req(args.request,resultHandler); + } + } + + public static class get_partitions_statistics_req extends org.apache.thrift.AsyncProcessFunction { + public get_partitions_statistics_req() { + super("get_partitions_statistics_req"); + } + + public get_partitions_statistics_req_args getEmptyArgsInstance() { + return new get_partitions_statistics_req_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(PartitionsStatsResult o) { + get_partitions_statistics_req_result result = new get_partitions_statistics_req_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + get_partitions_statistics_req_result result = new get_partitions_statistics_req_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_partitions_statistics_req_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_partitions_statistics_req(args.request,resultHandler); + } + } + + public static class get_aggr_stats_for extends org.apache.thrift.AsyncProcessFunction { + public get_aggr_stats_for() { + super("get_aggr_stats_for"); + } + + public get_aggr_stats_for_args getEmptyArgsInstance() { + return new get_aggr_stats_for_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(AggrStats o) { + get_aggr_stats_for_result result = new get_aggr_stats_for_result(); + result.success = o; + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + get_aggr_stats_for_result result = new get_aggr_stats_for_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o2 = (MetaException) e; + result.setO2IsSet(true); + msg = result; + } + else + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb,msg,msgType,seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, get_aggr_stats_for_args args, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws TException { + iface.get_aggr_stats_for(args.request,resultHandler); + } + } + + public static class set_aggr_stats_for extends org.apache.thrift.AsyncProcessFunction { + public set_aggr_stats_for() { + super("set_aggr_stats_for"); + } + + public set_aggr_stats_for_args getEmptyArgsInstance() { + return new set_aggr_stats_for_args(); + } + + public AsyncMethodCallback getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback() { + public void onComplete(Boolean o) { + set_aggr_stats_for_result result = new set_aggr_stats_for_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + set_aggr_stats_for_result result = new set_aggr_stats_for_result(); + if (e instanceof NoSuchObjectException) { + result.o1 = (NoSuchObjectException) e; + result.setO1IsSet(true); + msg = result; + } + else if (e instanceof InvalidObjectException) { + result.o2 = (InvalidObjectException) e; + result.setO2IsSet(true); + msg = result; + } + else if (e instanceof MetaException) { + result.o3 = (MetaException) e; + result.setO3IsSet(true); + msg = result; + } + else if (e instanceof InvalidInputException) { + result.o4 = (InvalidInputException) e; result.setO4IsSet(true); msg = result; } @@ -115166,13 +115343,1158 @@ public String getFieldName() { tmpMap.put(_Fields.STATS_OBJ, new org.apache.thrift.meta_data.FieldMetaData("stats_obj", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatistics.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_column_statistics_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_column_statistics_args.class, metaDataMap); + } + + public update_table_column_statistics_args() { + } + + public update_table_column_statistics_args( + ColumnStatistics stats_obj) + { + this(); + this.stats_obj = stats_obj; + } + + /** + * Performs a deep copy on other. + */ + public update_table_column_statistics_args(update_table_column_statistics_args other) { + if (other.isSetStats_obj()) { + this.stats_obj = new ColumnStatistics(other.stats_obj); + } + } + + public update_table_column_statistics_args deepCopy() { + return new update_table_column_statistics_args(this); + } + + @Override + public void clear() { + this.stats_obj = null; + } + + public ColumnStatistics getStats_obj() { + return this.stats_obj; + } + + public void setStats_obj(ColumnStatistics stats_obj) { + this.stats_obj = stats_obj; + } + + public void unsetStats_obj() { + this.stats_obj = null; + } + + /** Returns true if field stats_obj is set (has been assigned a value) and false otherwise */ + public boolean isSetStats_obj() { + return this.stats_obj != null; + } + + public void setStats_objIsSet(boolean value) { + if (!value) { + this.stats_obj = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case STATS_OBJ: + if (value == null) { + unsetStats_obj(); + } else { + setStats_obj((ColumnStatistics)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case STATS_OBJ: + return getStats_obj(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case STATS_OBJ: + return isSetStats_obj(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof update_table_column_statistics_args) + return this.equals((update_table_column_statistics_args)that); + return false; + } + + public boolean equals(update_table_column_statistics_args that) { + if (that == null) + return false; + + boolean this_present_stats_obj = true && this.isSetStats_obj(); + boolean that_present_stats_obj = true && that.isSetStats_obj(); + if (this_present_stats_obj || that_present_stats_obj) { + if (!(this_present_stats_obj && that_present_stats_obj)) + return false; + if (!this.stats_obj.equals(that.stats_obj)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_stats_obj = true && (isSetStats_obj()); + list.add(present_stats_obj); + if (present_stats_obj) + list.add(stats_obj); + + return list.hashCode(); + } + + @Override + public int compareTo(update_table_column_statistics_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetStats_obj()).compareTo(other.isSetStats_obj()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStats_obj()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stats_obj, other.stats_obj); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("update_table_column_statistics_args("); + boolean first = true; + + sb.append("stats_obj:"); + if (this.stats_obj == null) { + sb.append("null"); + } else { + sb.append(this.stats_obj); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (stats_obj != null) { + stats_obj.validate(); + } + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class update_table_column_statistics_argsStandardSchemeFactory implements SchemeFactory { + public update_table_column_statistics_argsStandardScheme getScheme() { + return new update_table_column_statistics_argsStandardScheme(); + } + } + + private static class update_table_column_statistics_argsStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // STATS_OBJ + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.stats_obj = new ColumnStatistics(); + struct.stats_obj.read(iprot); + struct.setStats_objIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.stats_obj != null) { + oprot.writeFieldBegin(STATS_OBJ_FIELD_DESC); + struct.stats_obj.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class update_table_column_statistics_argsTupleSchemeFactory implements SchemeFactory { + public update_table_column_statistics_argsTupleScheme getScheme() { + return new update_table_column_statistics_argsTupleScheme(); + } + } + + private static class update_table_column_statistics_argsTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetStats_obj()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetStats_obj()) { + struct.stats_obj.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.stats_obj = new ColumnStatistics(); + struct.stats_obj.read(iprot); + struct.setStats_objIsSet(true); + } + } + } + + } + + public static class update_table_column_statistics_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_table_column_statistics_result"); + + private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0); + private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField O2_FIELD_DESC = new org.apache.thrift.protocol.TField("o2", org.apache.thrift.protocol.TType.STRUCT, (short)2); + private static final org.apache.thrift.protocol.TField O3_FIELD_DESC = new org.apache.thrift.protocol.TField("o3", org.apache.thrift.protocol.TType.STRUCT, (short)3); + private static final org.apache.thrift.protocol.TField O4_FIELD_DESC = new org.apache.thrift.protocol.TField("o4", org.apache.thrift.protocol.TType.STRUCT, (short)4); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new update_table_column_statistics_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new update_table_column_statistics_resultTupleSchemeFactory()); + } + + private boolean success; // required + private NoSuchObjectException o1; // required + private InvalidObjectException o2; // required + private MetaException o3; // required + private InvalidInputException o4; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short)0, "success"), + O1((short)1, "o1"), + O2((short)2, "o2"), + O3((short)3, "o3"), + O4((short)4, "o4"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // O1 + return O1; + case 2: // O2 + return O2; + case 3: // O3 + return O3; + case 4: // O4 + return O4; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.O1, new org.apache.thrift.meta_data.FieldMetaData("o1", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O2, new org.apache.thrift.meta_data.FieldMetaData("o2", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O3, new org.apache.thrift.meta_data.FieldMetaData("o3", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_column_statistics_result.class, metaDataMap); + } + + public update_table_column_statistics_result() { + } + + public update_table_column_statistics_result( + boolean success, + NoSuchObjectException o1, + InvalidObjectException o2, + MetaException o3, + InvalidInputException o4) + { + this(); + this.success = success; + setSuccessIsSet(true); + this.o1 = o1; + this.o2 = o2; + this.o3 = o3; + this.o4 = o4; + } + + /** + * Performs a deep copy on other. + */ + public update_table_column_statistics_result(update_table_column_statistics_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + if (other.isSetO1()) { + this.o1 = new NoSuchObjectException(other.o1); + } + if (other.isSetO2()) { + this.o2 = new InvalidObjectException(other.o2); + } + if (other.isSetO3()) { + this.o3 = new MetaException(other.o3); + } + if (other.isSetO4()) { + this.o4 = new InvalidInputException(other.o4); + } + } + + public update_table_column_statistics_result deepCopy() { + return new update_table_column_statistics_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + this.o1 = null; + this.o2 = null; + this.o3 = null; + this.o4 = null; + } + + public boolean isSuccess() { + return this.success; + } + + public void setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + } + + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public NoSuchObjectException getO1() { + return this.o1; + } + + public void setO1(NoSuchObjectException o1) { + this.o1 = o1; + } + + public void unsetO1() { + this.o1 = null; + } + + /** Returns true if field o1 is set (has been assigned a value) and false otherwise */ + public boolean isSetO1() { + return this.o1 != null; + } + + public void setO1IsSet(boolean value) { + if (!value) { + this.o1 = null; + } + } + + public InvalidObjectException getO2() { + return this.o2; + } + + public void setO2(InvalidObjectException o2) { + this.o2 = o2; + } + + public void unsetO2() { + this.o2 = null; + } + + /** Returns true if field o2 is set (has been assigned a value) and false otherwise */ + public boolean isSetO2() { + return this.o2 != null; + } + + public void setO2IsSet(boolean value) { + if (!value) { + this.o2 = null; + } + } + + public MetaException getO3() { + return this.o3; + } + + public void setO3(MetaException o3) { + this.o3 = o3; + } + + public void unsetO3() { + this.o3 = null; + } + + /** Returns true if field o3 is set (has been assigned a value) and false otherwise */ + public boolean isSetO3() { + return this.o3 != null; + } + + public void setO3IsSet(boolean value) { + if (!value) { + this.o3 = null; + } + } + + public InvalidInputException getO4() { + return this.o4; + } + + public void setO4(InvalidInputException o4) { + this.o4 = o4; + } + + public void unsetO4() { + this.o4 = null; + } + + /** Returns true if field o4 is set (has been assigned a value) and false otherwise */ + public boolean isSetO4() { + return this.o4 != null; + } + + public void setO4IsSet(boolean value) { + if (!value) { + this.o4 = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean)value); + } + break; + + case O1: + if (value == null) { + unsetO1(); + } else { + setO1((NoSuchObjectException)value); + } + break; + + case O2: + if (value == null) { + unsetO2(); + } else { + setO2((InvalidObjectException)value); + } + break; + + case O3: + if (value == null) { + unsetO3(); + } else { + setO3((MetaException)value); + } + break; + + case O4: + if (value == null) { + unsetO4(); + } else { + setO4((InvalidInputException)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); + + case O1: + return getO1(); + + case O2: + return getO2(); + + case O3: + return getO3(); + + case O4: + return getO4(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + case O1: + return isSetO1(); + case O2: + return isSetO2(); + case O3: + return isSetO3(); + case O4: + return isSetO4(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof update_table_column_statistics_result) + return this.equals((update_table_column_statistics_result)that); + return false; + } + + public boolean equals(update_table_column_statistics_result that) { + if (that == null) + return false; + + boolean this_present_success = true; + boolean that_present_success = true; + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (this.success != that.success) + return false; + } + + boolean this_present_o1 = true && this.isSetO1(); + boolean that_present_o1 = true && that.isSetO1(); + if (this_present_o1 || that_present_o1) { + if (!(this_present_o1 && that_present_o1)) + return false; + if (!this.o1.equals(that.o1)) + return false; + } + + boolean this_present_o2 = true && this.isSetO2(); + boolean that_present_o2 = true && that.isSetO2(); + if (this_present_o2 || that_present_o2) { + if (!(this_present_o2 && that_present_o2)) + return false; + if (!this.o2.equals(that.o2)) + return false; + } + + boolean this_present_o3 = true && this.isSetO3(); + boolean that_present_o3 = true && that.isSetO3(); + if (this_present_o3 || that_present_o3) { + if (!(this_present_o3 && that_present_o3)) + return false; + if (!this.o3.equals(that.o3)) + return false; + } + + boolean this_present_o4 = true && this.isSetO4(); + boolean that_present_o4 = true && that.isSetO4(); + if (this_present_o4 || that_present_o4) { + if (!(this_present_o4 && that_present_o4)) + return false; + if (!this.o4.equals(that.o4)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List list = new ArrayList(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + boolean present_o1 = true && (isSetO1()); + list.add(present_o1); + if (present_o1) + list.add(o1); + + boolean present_o2 = true && (isSetO2()); + list.add(present_o2); + if (present_o2) + list.add(o2); + + boolean present_o3 = true && (isSetO3()); + list.add(present_o3); + if (present_o3) + list.add(o3); + + boolean present_o4 = true && (isSetO4()); + list.add(present_o4); + if (present_o4) + list.add(o4); + + return list.hashCode(); + } + + @Override + public int compareTo(update_table_column_statistics_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSuccess()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO1()).compareTo(other.isSetO1()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO1()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o1, other.o1); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO2()).compareTo(other.isSetO2()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO2()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o2, other.o2); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO3()).compareTo(other.isSetO3()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO3()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o3, other.o3); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetO4()).compareTo(other.isSetO4()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetO4()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.o4, other.o4); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("update_table_column_statistics_result("); + boolean first = true; + + sb.append("success:"); + sb.append(this.success); + first = false; + if (!first) sb.append(", "); + sb.append("o1:"); + if (this.o1 == null) { + sb.append("null"); + } else { + sb.append(this.o1); + } + first = false; + if (!first) sb.append(", "); + sb.append("o2:"); + if (this.o2 == null) { + sb.append("null"); + } else { + sb.append(this.o2); + } + first = false; + if (!first) sb.append(", "); + sb.append("o3:"); + if (this.o3 == null) { + sb.append("null"); + } else { + sb.append(this.o3); + } + first = false; + if (!first) sb.append(", "); + sb.append("o4:"); + if (this.o4 == null) { + sb.append("null"); + } else { + sb.append(this.o4); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class update_table_column_statistics_resultStandardSchemeFactory implements SchemeFactory { + public update_table_column_statistics_resultStandardScheme getScheme() { + return new update_table_column_statistics_resultStandardScheme(); + } + } + + private static class update_table_column_statistics_resultStandardScheme extends StandardScheme { + + public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 0: // SUCCESS + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // O1 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // O2 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // O3 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // O4 + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.o4 = new InvalidInputException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + oprot.writeFieldEnd(); + } + if (struct.o1 != null) { + oprot.writeFieldBegin(O1_FIELD_DESC); + struct.o1.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o2 != null) { + oprot.writeFieldBegin(O2_FIELD_DESC); + struct.o2.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o3 != null) { + oprot.writeFieldBegin(O3_FIELD_DESC); + struct.o3.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.o4 != null) { + oprot.writeFieldBegin(O4_FIELD_DESC); + struct.o4.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class update_table_column_statistics_resultTupleSchemeFactory implements SchemeFactory { + public update_table_column_statistics_resultTupleScheme getScheme() { + return new update_table_column_statistics_resultTupleScheme(); + } + } + + private static class update_table_column_statistics_resultTupleScheme extends TupleScheme { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetO1()) { + optionals.set(1); + } + if (struct.isSetO2()) { + optionals.set(2); + } + if (struct.isSetO3()) { + optionals.set(3); + } + if (struct.isSetO4()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + if (struct.isSetO1()) { + struct.o1.write(oprot); + } + if (struct.isSetO2()) { + struct.o2.write(oprot); + } + if (struct.isSetO3()) { + struct.o3.write(oprot); + } + if (struct.isSetO4()) { + struct.o4.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.o1 = new NoSuchObjectException(); + struct.o1.read(iprot); + struct.setO1IsSet(true); + } + if (incoming.get(2)) { + struct.o2 = new InvalidObjectException(); + struct.o2.read(iprot); + struct.setO2IsSet(true); + } + if (incoming.get(3)) { + struct.o3 = new MetaException(); + struct.o3.read(iprot); + struct.setO3IsSet(true); + } + if (incoming.get(4)) { + struct.o4 = new InvalidInputException(); + struct.o4.read(iprot); + struct.setO4IsSet(true); + } + } + } + + } + + public static class update_partition_column_statistics_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_partition_column_statistics_args"); + + private static final org.apache.thrift.protocol.TField STATS_OBJ_FIELD_DESC = new org.apache.thrift.protocol.TField("stats_obj", org.apache.thrift.protocol.TType.STRUCT, (short)1); + + private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new update_partition_column_statistics_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new update_partition_column_statistics_argsTupleSchemeFactory()); + } + + private ColumnStatistics stats_obj; // required + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + STATS_OBJ((short)1, "stats_obj"); + + private static final Map byName = new HashMap(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // STATS_OBJ + return STATS_OBJ; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.STATS_OBJ, new org.apache.thrift.meta_data.FieldMetaData("stats_obj", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatistics.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_partition_column_statistics_args.class, metaDataMap); } - public update_table_column_statistics_args() { + public update_partition_column_statistics_args() { } - public update_table_column_statistics_args( + public update_partition_column_statistics_args( ColumnStatistics stats_obj) { this(); @@ -115182,14 +116504,14 @@ public update_table_column_statistics_args( /** * Performs a deep copy on other. */ - public update_table_column_statistics_args(update_table_column_statistics_args other) { + public update_partition_column_statistics_args(update_partition_column_statistics_args other) { if (other.isSetStats_obj()) { this.stats_obj = new ColumnStatistics(other.stats_obj); } } - public update_table_column_statistics_args deepCopy() { - return new update_table_column_statistics_args(this); + public update_partition_column_statistics_args deepCopy() { + return new update_partition_column_statistics_args(this); } @Override @@ -115259,12 +116581,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof update_table_column_statistics_args) - return this.equals((update_table_column_statistics_args)that); + if (that instanceof update_partition_column_statistics_args) + return this.equals((update_partition_column_statistics_args)that); return false; } - public boolean equals(update_table_column_statistics_args that) { + public boolean equals(update_partition_column_statistics_args that) { if (that == null) return false; @@ -115293,7 +116615,7 @@ public int hashCode() { } @Override - public int compareTo(update_table_column_statistics_args other) { + public int compareTo(update_partition_column_statistics_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -115327,7 +116649,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("update_table_column_statistics_args("); + StringBuilder sb = new StringBuilder("update_partition_column_statistics_args("); boolean first = true; sb.append("stats_obj:"); @@ -115365,15 +116687,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class update_table_column_statistics_argsStandardSchemeFactory implements SchemeFactory { - public update_table_column_statistics_argsStandardScheme getScheme() { - return new update_table_column_statistics_argsStandardScheme(); + private static class update_partition_column_statistics_argsStandardSchemeFactory implements SchemeFactory { + public update_partition_column_statistics_argsStandardScheme getScheme() { + return new update_partition_column_statistics_argsStandardScheme(); } } - private static class update_table_column_statistics_argsStandardScheme extends StandardScheme { + private static class update_partition_column_statistics_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -115401,7 +116723,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -115416,16 +116738,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_colum } - private static class update_table_column_statistics_argsTupleSchemeFactory implements SchemeFactory { - public update_table_column_statistics_argsTupleScheme getScheme() { - return new update_table_column_statistics_argsTupleScheme(); + private static class update_partition_column_statistics_argsTupleSchemeFactory implements SchemeFactory { + public update_partition_column_statistics_argsTupleScheme getScheme() { + return new update_partition_column_statistics_argsTupleScheme(); } } - private static class update_table_column_statistics_argsTupleScheme extends TupleScheme { + private static class update_partition_column_statistics_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetStats_obj()) { @@ -115438,7 +116760,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { @@ -115451,8 +116773,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_ } - public static class update_table_column_statistics_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_table_column_statistics_result"); + public static class update_partition_column_statistics_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_partition_column_statistics_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); @@ -115462,8 +116784,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_ private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new update_table_column_statistics_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new update_table_column_statistics_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new update_partition_column_statistics_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new update_partition_column_statistics_resultTupleSchemeFactory()); } private boolean success; // required @@ -115559,13 +116881,13 @@ public String getFieldName() { tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_table_column_statistics_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_partition_column_statistics_result.class, metaDataMap); } - public update_table_column_statistics_result() { + public update_partition_column_statistics_result() { } - public update_table_column_statistics_result( + public update_partition_column_statistics_result( boolean success, NoSuchObjectException o1, InvalidObjectException o2, @@ -115584,7 +116906,7 @@ public update_table_column_statistics_result( /** * Performs a deep copy on other. */ - public update_table_column_statistics_result(update_table_column_statistics_result other) { + public update_partition_column_statistics_result(update_partition_column_statistics_result other) { __isset_bitfield = other.__isset_bitfield; this.success = other.success; if (other.isSetO1()) { @@ -115601,8 +116923,8 @@ public update_table_column_statistics_result(update_table_column_statistics_resu } } - public update_table_column_statistics_result deepCopy() { - return new update_table_column_statistics_result(this); + public update_partition_column_statistics_result deepCopy() { + return new update_partition_column_statistics_result(this); } @Override @@ -115820,12 +117142,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof update_table_column_statistics_result) - return this.equals((update_table_column_statistics_result)that); + if (that instanceof update_partition_column_statistics_result) + return this.equals((update_partition_column_statistics_result)that); return false; } - public boolean equals(update_table_column_statistics_result that) { + public boolean equals(update_partition_column_statistics_result that) { if (that == null) return false; @@ -115910,7 +117232,7 @@ public int hashCode() { } @Override - public int compareTo(update_table_column_statistics_result other) { + public int compareTo(update_partition_column_statistics_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -115984,7 +117306,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("update_table_column_statistics_result("); + StringBuilder sb = new StringBuilder("update_partition_column_statistics_result("); boolean first = true; sb.append("success:"); @@ -116049,15 +117371,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class update_table_column_statistics_resultStandardSchemeFactory implements SchemeFactory { - public update_table_column_statistics_resultStandardScheme getScheme() { - return new update_table_column_statistics_resultStandardScheme(); + private static class update_partition_column_statistics_resultStandardSchemeFactory implements SchemeFactory { + public update_partition_column_statistics_resultStandardScheme getScheme() { + return new update_partition_column_statistics_resultStandardScheme(); } } - private static class update_table_column_statistics_resultStandardScheme extends StandardScheme { + private static class update_partition_column_statistics_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -116120,7 +117442,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, update_table_column struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -116155,16 +117477,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, update_table_colum } - private static class update_table_column_statistics_resultTupleSchemeFactory implements SchemeFactory { - public update_table_column_statistics_resultTupleScheme getScheme() { - return new update_table_column_statistics_resultTupleScheme(); + private static class update_partition_column_statistics_resultTupleSchemeFactory implements SchemeFactory { + public update_partition_column_statistics_resultTupleScheme getScheme() { + return new update_partition_column_statistics_resultTupleScheme(); } } - private static class update_table_column_statistics_resultTupleScheme extends TupleScheme { + private static class update_partition_column_statistics_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -116201,7 +117523,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, update_table_column } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_statistics_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { @@ -116233,22 +117555,22 @@ public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_ } - public static class update_partition_column_statistics_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_partition_column_statistics_args"); + public static class renew_column_statistics_args implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("renew_column_statistics_args"); - private static final org.apache.thrift.protocol.TField STATS_OBJ_FIELD_DESC = new org.apache.thrift.protocol.TField("stats_obj", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1); private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new update_partition_column_statistics_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new update_partition_column_statistics_argsTupleSchemeFactory()); + schemes.put(StandardScheme.class, new renew_column_statistics_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new renew_column_statistics_argsTupleSchemeFactory()); } - private ColumnStatistics stats_obj; // required + private SetColumnStatsRequest request; // required /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ public enum _Fields implements org.apache.thrift.TFieldIdEnum { - STATS_OBJ((short)1, "stats_obj"); + REQUEST((short)1, "request"); private static final Map byName = new HashMap(); @@ -116263,8 +117585,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, update_table_column_ */ public static _Fields findByThriftId(int fieldId) { switch(fieldId) { - case 1: // STATS_OBJ - return STATS_OBJ; + case 1: // REQUEST + return REQUEST; default: return null; } @@ -116308,70 +117630,70 @@ public String getFieldName() { public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.STATS_OBJ, new org.apache.thrift.meta_data.FieldMetaData("stats_obj", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ColumnStatistics.class))); + tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, SetColumnStatsRequest.class))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_partition_column_statistics_args.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(renew_column_statistics_args.class, metaDataMap); } - public update_partition_column_statistics_args() { + public renew_column_statistics_args() { } - public update_partition_column_statistics_args( - ColumnStatistics stats_obj) + public renew_column_statistics_args( + SetColumnStatsRequest request) { this(); - this.stats_obj = stats_obj; + this.request = request; } /** * Performs a deep copy on other. */ - public update_partition_column_statistics_args(update_partition_column_statistics_args other) { - if (other.isSetStats_obj()) { - this.stats_obj = new ColumnStatistics(other.stats_obj); + public renew_column_statistics_args(renew_column_statistics_args other) { + if (other.isSetRequest()) { + this.request = new SetColumnStatsRequest(other.request); } } - public update_partition_column_statistics_args deepCopy() { - return new update_partition_column_statistics_args(this); + public renew_column_statistics_args deepCopy() { + return new renew_column_statistics_args(this); } @Override public void clear() { - this.stats_obj = null; + this.request = null; } - public ColumnStatistics getStats_obj() { - return this.stats_obj; + public SetColumnStatsRequest getRequest() { + return this.request; } - public void setStats_obj(ColumnStatistics stats_obj) { - this.stats_obj = stats_obj; + public void setRequest(SetColumnStatsRequest request) { + this.request = request; } - public void unsetStats_obj() { - this.stats_obj = null; + public void unsetRequest() { + this.request = null; } - /** Returns true if field stats_obj is set (has been assigned a value) and false otherwise */ - public boolean isSetStats_obj() { - return this.stats_obj != null; + /** Returns true if field request is set (has been assigned a value) and false otherwise */ + public boolean isSetRequest() { + return this.request != null; } - public void setStats_objIsSet(boolean value) { + public void setRequestIsSet(boolean value) { if (!value) { - this.stats_obj = null; + this.request = null; } } public void setFieldValue(_Fields field, Object value) { switch (field) { - case STATS_OBJ: + case REQUEST: if (value == null) { - unsetStats_obj(); + unsetRequest(); } else { - setStats_obj((ColumnStatistics)value); + setRequest((SetColumnStatsRequest)value); } break; @@ -116380,8 +117702,8 @@ public void setFieldValue(_Fields field, Object value) { public Object getFieldValue(_Fields field) { switch (field) { - case STATS_OBJ: - return getStats_obj(); + case REQUEST: + return getRequest(); } throw new IllegalStateException(); @@ -116394,8 +117716,8 @@ public boolean isSet(_Fields field) { } switch (field) { - case STATS_OBJ: - return isSetStats_obj(); + case REQUEST: + return isSetRequest(); } throw new IllegalStateException(); } @@ -116404,21 +117726,21 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof update_partition_column_statistics_args) - return this.equals((update_partition_column_statistics_args)that); + if (that instanceof renew_column_statistics_args) + return this.equals((renew_column_statistics_args)that); return false; } - public boolean equals(update_partition_column_statistics_args that) { + public boolean equals(renew_column_statistics_args that) { if (that == null) return false; - boolean this_present_stats_obj = true && this.isSetStats_obj(); - boolean that_present_stats_obj = true && that.isSetStats_obj(); - if (this_present_stats_obj || that_present_stats_obj) { - if (!(this_present_stats_obj && that_present_stats_obj)) + boolean this_present_request = true && this.isSetRequest(); + boolean that_present_request = true && that.isSetRequest(); + if (this_present_request || that_present_request) { + if (!(this_present_request && that_present_request)) return false; - if (!this.stats_obj.equals(that.stats_obj)) + if (!this.request.equals(that.request)) return false; } @@ -116429,28 +117751,28 @@ public boolean equals(update_partition_column_statistics_args that) { public int hashCode() { List list = new ArrayList(); - boolean present_stats_obj = true && (isSetStats_obj()); - list.add(present_stats_obj); - if (present_stats_obj) - list.add(stats_obj); + boolean present_request = true && (isSetRequest()); + list.add(present_request); + if (present_request) + list.add(request); return list.hashCode(); } @Override - public int compareTo(update_partition_column_statistics_args other) { + public int compareTo(renew_column_statistics_args other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; - lastComparison = Boolean.valueOf(isSetStats_obj()).compareTo(other.isSetStats_obj()); + lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest()); if (lastComparison != 0) { return lastComparison; } - if (isSetStats_obj()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stats_obj, other.stats_obj); + if (isSetRequest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request); if (lastComparison != 0) { return lastComparison; } @@ -116472,14 +117794,14 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("update_partition_column_statistics_args("); + StringBuilder sb = new StringBuilder("renew_column_statistics_args("); boolean first = true; - sb.append("stats_obj:"); - if (this.stats_obj == null) { + sb.append("request:"); + if (this.request == null) { sb.append("null"); } else { - sb.append(this.stats_obj); + sb.append(this.request); } first = false; sb.append(")"); @@ -116489,8 +117811,8 @@ public String toString() { public void validate() throws org.apache.thrift.TException { // check for required fields // check for sub-struct validity - if (stats_obj != null) { - stats_obj.validate(); + if (request != null) { + request.validate(); } } @@ -116510,15 +117832,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class update_partition_column_statistics_argsStandardSchemeFactory implements SchemeFactory { - public update_partition_column_statistics_argsStandardScheme getScheme() { - return new update_partition_column_statistics_argsStandardScheme(); + private static class renew_column_statistics_argsStandardSchemeFactory implements SchemeFactory { + public renew_column_statistics_argsStandardScheme getScheme() { + return new renew_column_statistics_argsStandardScheme(); } } - private static class update_partition_column_statistics_argsStandardScheme extends StandardScheme { + private static class renew_column_statistics_argsStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, renew_column_statistics_args struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -116528,11 +117850,11 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_co break; } switch (schemeField.id) { - case 1: // STATS_OBJ + case 1: // REQUEST if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.stats_obj = new ColumnStatistics(); - struct.stats_obj.read(iprot); - struct.setStats_objIsSet(true); + struct.request = new SetColumnStatsRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } @@ -116546,13 +117868,13 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_co struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, renew_column_statistics_args struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); - if (struct.stats_obj != null) { - oprot.writeFieldBegin(STATS_OBJ_FIELD_DESC); - struct.stats_obj.write(oprot); + if (struct.request != null) { + oprot.writeFieldBegin(REQUEST_FIELD_DESC); + struct.request.write(oprot); oprot.writeFieldEnd(); } oprot.writeFieldStop(); @@ -116561,43 +117883,43 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_c } - private static class update_partition_column_statistics_argsTupleSchemeFactory implements SchemeFactory { - public update_partition_column_statistics_argsTupleScheme getScheme() { - return new update_partition_column_statistics_argsTupleScheme(); + private static class renew_column_statistics_argsTupleSchemeFactory implements SchemeFactory { + public renew_column_statistics_argsTupleScheme getScheme() { + return new renew_column_statistics_argsTupleScheme(); } } - private static class update_partition_column_statistics_argsTupleScheme extends TupleScheme { + private static class renew_column_statistics_argsTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, renew_column_statistics_args struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); - if (struct.isSetStats_obj()) { + if (struct.isSetRequest()) { optionals.set(0); } oprot.writeBitSet(optionals, 1); - if (struct.isSetStats_obj()) { - struct.stats_obj.write(oprot); + if (struct.isSetRequest()) { + struct.request.write(oprot); } } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_args struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, renew_column_statistics_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(1); if (incoming.get(0)) { - struct.stats_obj = new ColumnStatistics(); - struct.stats_obj.read(iprot); - struct.setStats_objIsSet(true); + struct.request = new SetColumnStatsRequest(); + struct.request.read(iprot); + struct.setRequestIsSet(true); } } } } - public static class update_partition_column_statistics_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("update_partition_column_statistics_result"); + public static class renew_column_statistics_result implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("renew_column_statistics_result"); private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.BOOL, (short)0); private static final org.apache.thrift.protocol.TField O1_FIELD_DESC = new org.apache.thrift.protocol.TField("o1", org.apache.thrift.protocol.TType.STRUCT, (short)1); @@ -116607,8 +117929,8 @@ public void read(org.apache.thrift.protocol.TProtocol prot, update_partition_col private static final Map, SchemeFactory> schemes = new HashMap, SchemeFactory>(); static { - schemes.put(StandardScheme.class, new update_partition_column_statistics_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new update_partition_column_statistics_resultTupleSchemeFactory()); + schemes.put(StandardScheme.class, new renew_column_statistics_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new renew_column_statistics_resultTupleSchemeFactory()); } private boolean success; // required @@ -116704,13 +118026,13 @@ public String getFieldName() { tmpMap.put(_Fields.O4, new org.apache.thrift.meta_data.FieldMetaData("o4", org.apache.thrift.TFieldRequirementType.DEFAULT, new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(update_partition_column_statistics_result.class, metaDataMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(renew_column_statistics_result.class, metaDataMap); } - public update_partition_column_statistics_result() { + public renew_column_statistics_result() { } - public update_partition_column_statistics_result( + public renew_column_statistics_result( boolean success, NoSuchObjectException o1, InvalidObjectException o2, @@ -116729,7 +118051,7 @@ public update_partition_column_statistics_result( /** * Performs a deep copy on other. */ - public update_partition_column_statistics_result(update_partition_column_statistics_result other) { + public renew_column_statistics_result(renew_column_statistics_result other) { __isset_bitfield = other.__isset_bitfield; this.success = other.success; if (other.isSetO1()) { @@ -116746,8 +118068,8 @@ public update_partition_column_statistics_result(update_partition_column_statist } } - public update_partition_column_statistics_result deepCopy() { - return new update_partition_column_statistics_result(this); + public renew_column_statistics_result deepCopy() { + return new renew_column_statistics_result(this); } @Override @@ -116965,12 +118287,12 @@ public boolean isSet(_Fields field) { public boolean equals(Object that) { if (that == null) return false; - if (that instanceof update_partition_column_statistics_result) - return this.equals((update_partition_column_statistics_result)that); + if (that instanceof renew_column_statistics_result) + return this.equals((renew_column_statistics_result)that); return false; } - public boolean equals(update_partition_column_statistics_result that) { + public boolean equals(renew_column_statistics_result that) { if (that == null) return false; @@ -117055,7 +118377,7 @@ public int hashCode() { } @Override - public int compareTo(update_partition_column_statistics_result other) { + public int compareTo(renew_column_statistics_result other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } @@ -117129,7 +118451,7 @@ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache. @Override public String toString() { - StringBuilder sb = new StringBuilder("update_partition_column_statistics_result("); + StringBuilder sb = new StringBuilder("renew_column_statistics_result("); boolean first = true; sb.append("success:"); @@ -117194,15 +118516,15 @@ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException } } - private static class update_partition_column_statistics_resultStandardSchemeFactory implements SchemeFactory { - public update_partition_column_statistics_resultStandardScheme getScheme() { - return new update_partition_column_statistics_resultStandardScheme(); + private static class renew_column_statistics_resultStandardSchemeFactory implements SchemeFactory { + public renew_column_statistics_resultStandardScheme getScheme() { + return new renew_column_statistics_resultStandardScheme(); } } - private static class update_partition_column_statistics_resultStandardScheme extends StandardScheme { + private static class renew_column_statistics_resultStandardScheme extends StandardScheme { - public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol iprot, renew_column_statistics_result struct) throws org.apache.thrift.TException { org.apache.thrift.protocol.TField schemeField; iprot.readStructBegin(); while (true) @@ -117265,7 +118587,7 @@ public void read(org.apache.thrift.protocol.TProtocol iprot, update_partition_co struct.validate(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol oprot, renew_column_statistics_result struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); @@ -117300,16 +118622,16 @@ public void write(org.apache.thrift.protocol.TProtocol oprot, update_partition_c } - private static class update_partition_column_statistics_resultTupleSchemeFactory implements SchemeFactory { - public update_partition_column_statistics_resultTupleScheme getScheme() { - return new update_partition_column_statistics_resultTupleScheme(); + private static class renew_column_statistics_resultTupleSchemeFactory implements SchemeFactory { + public renew_column_statistics_resultTupleScheme getScheme() { + return new renew_column_statistics_resultTupleScheme(); } } - private static class update_partition_column_statistics_resultTupleScheme extends TupleScheme { + private static class renew_column_statistics_resultTupleScheme extends TupleScheme { @Override - public void write(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { + public void write(org.apache.thrift.protocol.TProtocol prot, renew_column_statistics_result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetSuccess()) { @@ -117346,7 +118668,7 @@ public void write(org.apache.thrift.protocol.TProtocol prot, update_partition_co } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, update_partition_column_statistics_result struct) throws org.apache.thrift.TException { + public void read(org.apache.thrift.protocol.TProtocol prot, renew_column_statistics_result struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(5); if (incoming.get(0)) { diff --git a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php index 4f0c8fd..d046762 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php +++ b/metastore/src/gen/thrift/gen-php/metastore/ThriftHiveMetastore.php @@ -741,6 +741,15 @@ interface ThriftHiveMetastoreIf extends \FacebookServiceIf { */ public function update_partition_column_statistics(\metastore\ColumnStatistics $stats_obj); /** + * @param \metastore\SetColumnStatsRequest $request + * @return bool + * @throws \metastore\NoSuchObjectException + * @throws \metastore\InvalidObjectException + * @throws \metastore\MetaException + * @throws \metastore\InvalidInputException + */ + public function renew_column_statistics(\metastore\SetColumnStatsRequest $request); + /** * @param string $db_name * @param string $tbl_name * @param string $col_name @@ -5988,6 +5997,69 @@ class ThriftHiveMetastoreClient extends \FacebookServiceClient implements \metas throw new \Exception("update_partition_column_statistics failed: unknown result"); } + public function renew_column_statistics(\metastore\SetColumnStatsRequest $request) + { + $this->send_renew_column_statistics($request); + return $this->recv_renew_column_statistics(); + } + + public function send_renew_column_statistics(\metastore\SetColumnStatsRequest $request) + { + $args = new \metastore\ThriftHiveMetastore_renew_column_statistics_args(); + $args->request = $request; + $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary'); + if ($bin_accel) + { + thrift_protocol_write_binary($this->output_, 'renew_column_statistics', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite()); + } + else + { + $this->output_->writeMessageBegin('renew_column_statistics', TMessageType::CALL, $this->seqid_); + $args->write($this->output_); + $this->output_->writeMessageEnd(); + $this->output_->getTransport()->flush(); + } + } + + public function recv_renew_column_statistics() + { + $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary'); + if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\metastore\ThriftHiveMetastore_renew_column_statistics_result', $this->input_->isStrictRead()); + else + { + $rseqid = 0; + $fname = null; + $mtype = 0; + + $this->input_->readMessageBegin($fname, $mtype, $rseqid); + if ($mtype == TMessageType::EXCEPTION) { + $x = new TApplicationException(); + $x->read($this->input_); + $this->input_->readMessageEnd(); + throw $x; + } + $result = new \metastore\ThriftHiveMetastore_renew_column_statistics_result(); + $result->read($this->input_); + $this->input_->readMessageEnd(); + } + if ($result->success !== null) { + return $result->success; + } + if ($result->o1 !== null) { + throw $result->o1; + } + if ($result->o2 !== null) { + throw $result->o2; + } + if ($result->o3 !== null) { + throw $result->o3; + } + if ($result->o4 !== null) { + throw $result->o4; + } + throw new \Exception("renew_column_statistics failed: unknown result"); + } + public function get_table_column_statistics($db_name, $tbl_name, $col_name) { $this->send_get_table_column_statistics($db_name, $tbl_name, $col_name); @@ -31053,6 +31125,261 @@ class ThriftHiveMetastore_update_partition_column_statistics_result { } +class ThriftHiveMetastore_renew_column_statistics_args { + static $_TSPEC; + + /** + * @var \metastore\SetColumnStatsRequest + */ + public $request = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'request', + 'type' => TType::STRUCT, + 'class' => '\metastore\SetColumnStatsRequest', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['request'])) { + $this->request = $vals['request']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_renew_column_statistics_args'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->request = new \metastore\SetColumnStatsRequest(); + $xfer += $this->request->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_renew_column_statistics_args'); + if ($this->request !== null) { + if (!is_object($this->request)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('request', TType::STRUCT, 1); + $xfer += $this->request->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class ThriftHiveMetastore_renew_column_statistics_result { + static $_TSPEC; + + /** + * @var bool + */ + public $success = null; + /** + * @var \metastore\NoSuchObjectException + */ + public $o1 = null; + /** + * @var \metastore\InvalidObjectException + */ + public $o2 = null; + /** + * @var \metastore\MetaException + */ + public $o3 = null; + /** + * @var \metastore\InvalidInputException + */ + public $o4 = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 0 => array( + 'var' => 'success', + 'type' => TType::BOOL, + ), + 1 => array( + 'var' => 'o1', + 'type' => TType::STRUCT, + 'class' => '\metastore\NoSuchObjectException', + ), + 2 => array( + 'var' => 'o2', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidObjectException', + ), + 3 => array( + 'var' => 'o3', + 'type' => TType::STRUCT, + 'class' => '\metastore\MetaException', + ), + 4 => array( + 'var' => 'o4', + 'type' => TType::STRUCT, + 'class' => '\metastore\InvalidInputException', + ), + ); + } + if (is_array($vals)) { + if (isset($vals['success'])) { + $this->success = $vals['success']; + } + if (isset($vals['o1'])) { + $this->o1 = $vals['o1']; + } + if (isset($vals['o2'])) { + $this->o2 = $vals['o2']; + } + if (isset($vals['o3'])) { + $this->o3 = $vals['o3']; + } + if (isset($vals['o4'])) { + $this->o4 = $vals['o4']; + } + } + } + + public function getName() { + return 'ThriftHiveMetastore_renew_column_statistics_result'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 0: + if ($ftype == TType::BOOL) { + $xfer += $input->readBool($this->success); + } else { + $xfer += $input->skip($ftype); + } + break; + case 1: + if ($ftype == TType::STRUCT) { + $this->o1 = new \metastore\NoSuchObjectException(); + $xfer += $this->o1->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::STRUCT) { + $this->o2 = new \metastore\InvalidObjectException(); + $xfer += $this->o2->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 3: + if ($ftype == TType::STRUCT) { + $this->o3 = new \metastore\MetaException(); + $xfer += $this->o3->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 4: + if ($ftype == TType::STRUCT) { + $this->o4 = new \metastore\InvalidInputException(); + $xfer += $this->o4->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('ThriftHiveMetastore_renew_column_statistics_result'); + if ($this->success !== null) { + $xfer += $output->writeFieldBegin('success', TType::BOOL, 0); + $xfer += $output->writeBool($this->success); + $xfer += $output->writeFieldEnd(); + } + if ($this->o1 !== null) { + $xfer += $output->writeFieldBegin('o1', TType::STRUCT, 1); + $xfer += $this->o1->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o2 !== null) { + $xfer += $output->writeFieldBegin('o2', TType::STRUCT, 2); + $xfer += $this->o2->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o3 !== null) { + $xfer += $output->writeFieldBegin('o3', TType::STRUCT, 3); + $xfer += $this->o3->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->o4 !== null) { + $xfer += $output->writeFieldBegin('o4', TType::STRUCT, 4); + $xfer += $this->o4->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + class ThriftHiveMetastore_get_table_column_statistics_args { static $_TSPEC; diff --git a/metastore/src/gen/thrift/gen-php/metastore/Types.php b/metastore/src/gen/thrift/gen-php/metastore/Types.php index e2fa963..aa80154 100644 --- a/metastore/src/gen/thrift/gen-php/metastore/Types.php +++ b/metastore/src/gen/thrift/gen-php/metastore/Types.php @@ -8340,6 +8340,10 @@ class SetPartitionsStatsRequest { * @var \metastore\ColumnStatistics[] */ public $colStats = null; + /** + * @var int + */ + public $numBitVector = null; public function __construct($vals=null) { if (!isset(self::$_TSPEC)) { @@ -8353,12 +8357,19 @@ class SetPartitionsStatsRequest { 'class' => '\metastore\ColumnStatistics', ), ), + 2 => array( + 'var' => 'numBitVector', + 'type' => TType::I32, + ), ); } if (is_array($vals)) { if (isset($vals['colStats'])) { $this->colStats = $vals['colStats']; } + if (isset($vals['numBitVector'])) { + $this->numBitVector = $vals['numBitVector']; + } } } @@ -8399,6 +8410,13 @@ class SetPartitionsStatsRequest { $xfer += $input->skip($ftype); } break; + case 2: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->numBitVector); + } else { + $xfer += $input->skip($ftype); + } + break; default: $xfer += $input->skip($ftype); break; @@ -8429,6 +8447,114 @@ class SetPartitionsStatsRequest { } $xfer += $output->writeFieldEnd(); } + if ($this->numBitVector !== null) { + $xfer += $output->writeFieldBegin('numBitVector', TType::I32, 2); + $xfer += $output->writeI32($this->numBitVector); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; + } + +} + +class SetColumnStatsRequest { + static $_TSPEC; + + /** + * @var \metastore\ColumnStatistics + */ + public $colStats = null; + /** + * @var int + */ + public $numBitVector = null; + + public function __construct($vals=null) { + if (!isset(self::$_TSPEC)) { + self::$_TSPEC = array( + 1 => array( + 'var' => 'colStats', + 'type' => TType::STRUCT, + 'class' => '\metastore\ColumnStatistics', + ), + 2 => array( + 'var' => 'numBitVector', + 'type' => TType::I32, + ), + ); + } + if (is_array($vals)) { + if (isset($vals['colStats'])) { + $this->colStats = $vals['colStats']; + } + if (isset($vals['numBitVector'])) { + $this->numBitVector = $vals['numBitVector']; + } + } + } + + public function getName() { + return 'SetColumnStatsRequest'; + } + + public function read($input) + { + $xfer = 0; + $fname = null; + $ftype = 0; + $fid = 0; + $xfer += $input->readStructBegin($fname); + while (true) + { + $xfer += $input->readFieldBegin($fname, $ftype, $fid); + if ($ftype == TType::STOP) { + break; + } + switch ($fid) + { + case 1: + if ($ftype == TType::STRUCT) { + $this->colStats = new \metastore\ColumnStatistics(); + $xfer += $this->colStats->read($input); + } else { + $xfer += $input->skip($ftype); + } + break; + case 2: + if ($ftype == TType::I32) { + $xfer += $input->readI32($this->numBitVector); + } else { + $xfer += $input->skip($ftype); + } + break; + default: + $xfer += $input->skip($ftype); + break; + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; + } + + public function write($output) { + $xfer = 0; + $xfer += $output->writeStructBegin('SetColumnStatsRequest'); + if ($this->colStats !== null) { + if (!is_object($this->colStats)) { + throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA); + } + $xfer += $output->writeFieldBegin('colStats', TType::STRUCT, 1); + $xfer += $this->colStats->write($output); + $xfer += $output->writeFieldEnd(); + } + if ($this->numBitVector !== null) { + $xfer += $output->writeFieldBegin('numBitVector', TType::I32, 2); + $xfer += $output->writeI32($this->numBitVector); + $xfer += $output->writeFieldEnd(); + } $xfer += $output->writeFieldStop(); $xfer += $output->writeStructEnd(); return $xfer; diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote index 3ec46f1..2d62ff4 100755 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore-remote @@ -106,6 +106,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help': print(' ForeignKeysResponse get_foreign_keys(ForeignKeysRequest request)') print(' bool update_table_column_statistics(ColumnStatistics stats_obj)') print(' bool update_partition_column_statistics(ColumnStatistics stats_obj)') + print(' bool renew_column_statistics(SetColumnStatsRequest request)') print(' ColumnStatistics get_table_column_statistics(string db_name, string tbl_name, string col_name)') print(' ColumnStatistics get_partition_column_statistics(string db_name, string tbl_name, string part_name, string col_name)') print(' TableStatsResult get_table_statistics_req(TableStatsRequest request)') @@ -731,6 +732,12 @@ elif cmd == 'update_partition_column_statistics': sys.exit(1) pp.pprint(client.update_partition_column_statistics(eval(args[0]),)) +elif cmd == 'renew_column_statistics': + if len(args) != 1: + print('renew_column_statistics requires 1 args') + sys.exit(1) + pp.pprint(client.renew_column_statistics(eval(args[0]),)) + elif cmd == 'get_table_column_statistics': if len(args) != 3: print('get_table_column_statistics requires 3 args') diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 119a5f1..6a47699 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -732,6 +732,13 @@ def update_partition_column_statistics(self, stats_obj): """ pass + def renew_column_statistics(self, request): + """ + Parameters: + - request + """ + pass + def get_table_column_statistics(self, db_name, tbl_name, col_name): """ Parameters: @@ -4346,6 +4353,45 @@ def recv_update_partition_column_statistics(self): raise result.o4 raise TApplicationException(TApplicationException.MISSING_RESULT, "update_partition_column_statistics failed: unknown result") + def renew_column_statistics(self, request): + """ + Parameters: + - request + """ + self.send_renew_column_statistics(request) + return self.recv_renew_column_statistics() + + def send_renew_column_statistics(self, request): + self._oprot.writeMessageBegin('renew_column_statistics', TMessageType.CALL, self._seqid) + args = renew_column_statistics_args() + args.request = request + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_renew_column_statistics(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = renew_column_statistics_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + if result.o4 is not None: + raise result.o4 + raise TApplicationException(TApplicationException.MISSING_RESULT, "renew_column_statistics failed: unknown result") + def get_table_column_statistics(self, db_name, tbl_name, col_name): """ Parameters: @@ -6562,6 +6608,7 @@ def __init__(self, handler): self._processMap["get_foreign_keys"] = Processor.process_get_foreign_keys self._processMap["update_table_column_statistics"] = Processor.process_update_table_column_statistics self._processMap["update_partition_column_statistics"] = Processor.process_update_partition_column_statistics + self._processMap["renew_column_statistics"] = Processor.process_renew_column_statistics self._processMap["get_table_column_statistics"] = Processor.process_get_table_column_statistics self._processMap["get_partition_column_statistics"] = Processor.process_get_partition_column_statistics self._processMap["get_table_statistics_req"] = Processor.process_get_table_statistics_req @@ -8773,6 +8820,37 @@ def process_update_partition_column_statistics(self, seqid, iprot, oprot): oprot.writeMessageEnd() oprot.trans.flush() + def process_renew_column_statistics(self, seqid, iprot, oprot): + args = renew_column_statistics_args() + args.read(iprot) + iprot.readMessageEnd() + result = renew_column_statistics_result() + try: + result.success = self._handler.renew_column_statistics(args.request) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except InvalidInputException as o4: + msg_type = TMessageType.REPLY + result.o4 = o4 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("renew_column_statistics", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + def process_get_table_column_statistics(self, seqid, iprot, oprot): args = get_table_column_statistics_args() args.read(iprot) @@ -25549,6 +25627,192 @@ def __eq__(self, other): def __ne__(self, other): return not (self == other) +class renew_column_statistics_args: + """ + Attributes: + - request + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'request', (SetColumnStatsRequest, SetColumnStatsRequest.thrift_spec), None, ), # 1 + ) + + def __init__(self, request=None,): + self.request = request + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.request = SetColumnStatsRequest() + self.request.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('renew_column_statistics_args') + if self.request is not None: + oprot.writeFieldBegin('request', TType.STRUCT, 1) + self.request.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.request) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class renew_column_statistics_result: + """ + Attributes: + - success + - o1 + - o2 + - o3 + - o4 + """ + + thrift_spec = ( + (0, TType.BOOL, 'success', None, None, ), # 0 + (1, TType.STRUCT, 'o1', (NoSuchObjectException, NoSuchObjectException.thrift_spec), None, ), # 1 + (2, TType.STRUCT, 'o2', (InvalidObjectException, InvalidObjectException.thrift_spec), None, ), # 2 + (3, TType.STRUCT, 'o3', (MetaException, MetaException.thrift_spec), None, ), # 3 + (4, TType.STRUCT, 'o4', (InvalidInputException, InvalidInputException.thrift_spec), None, ), # 4 + ) + + def __init__(self, success=None, o1=None, o2=None, o3=None, o4=None,): + self.success = success + self.o1 = o1 + self.o2 = o2 + self.o3 = o3 + self.o4 = o4 + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 0: + if ftype == TType.BOOL: + self.success = iprot.readBool() + else: + iprot.skip(ftype) + elif fid == 1: + if ftype == TType.STRUCT: + self.o1 = NoSuchObjectException() + self.o1.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRUCT: + self.o2 = InvalidObjectException() + self.o2.read(iprot) + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRUCT: + self.o3 = MetaException() + self.o3.read(iprot) + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRUCT: + self.o4 = InvalidInputException() + self.o4.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('renew_column_statistics_result') + if self.success is not None: + oprot.writeFieldBegin('success', TType.BOOL, 0) + oprot.writeBool(self.success) + oprot.writeFieldEnd() + if self.o1 is not None: + oprot.writeFieldBegin('o1', TType.STRUCT, 1) + self.o1.write(oprot) + oprot.writeFieldEnd() + if self.o2 is not None: + oprot.writeFieldBegin('o2', TType.STRUCT, 2) + self.o2.write(oprot) + oprot.writeFieldEnd() + if self.o3 is not None: + oprot.writeFieldBegin('o3', TType.STRUCT, 3) + self.o3.write(oprot) + oprot.writeFieldEnd() + if self.o4 is not None: + oprot.writeFieldBegin('o4', TType.STRUCT, 4) + self.o4.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.success) + value = (value * 31) ^ hash(self.o1) + value = (value * 31) ^ hash(self.o2) + value = (value * 31) ^ hash(self.o3) + value = (value * 31) ^ hash(self.o4) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class get_table_column_statistics_args: """ Attributes: diff --git a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index f008788..f4156ad 100644 --- a/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -5674,15 +5674,18 @@ class SetPartitionsStatsRequest: """ Attributes: - colStats + - numBitVector """ thrift_spec = ( None, # 0 (1, TType.LIST, 'colStats', (TType.STRUCT,(ColumnStatistics, ColumnStatistics.thrift_spec)), None, ), # 1 + (2, TType.I32, 'numBitVector', None, None, ), # 2 ) - def __init__(self, colStats=None,): + def __init__(self, colStats=None, numBitVector=None,): self.colStats = colStats + self.numBitVector = numBitVector def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -5704,6 +5707,11 @@ def read(self, iprot): iprot.readListEnd() else: iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I32: + self.numBitVector = iprot.readI32() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -5721,6 +5729,91 @@ def write(self, oprot): iter259.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() + if self.numBitVector is not None: + oprot.writeFieldBegin('numBitVector', TType.I32, 2) + oprot.writeI32(self.numBitVector) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + if self.colStats is None: + raise TProtocol.TProtocolException(message='Required field colStats is unset!') + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.colStats) + value = (value * 31) ^ hash(self.numBitVector) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class SetColumnStatsRequest: + """ + Attributes: + - colStats + - numBitVector + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRUCT, 'colStats', (ColumnStatistics, ColumnStatistics.thrift_spec), None, ), # 1 + (2, TType.I32, 'numBitVector', None, None, ), # 2 + ) + + def __init__(self, colStats=None, numBitVector=None,): + self.colStats = colStats + self.numBitVector = numBitVector + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRUCT: + self.colStats = ColumnStatistics() + self.colStats.read(iprot) + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I32: + self.numBitVector = iprot.readI32() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('SetColumnStatsRequest') + if self.colStats is not None: + oprot.writeFieldBegin('colStats', TType.STRUCT, 1) + self.colStats.write(oprot) + oprot.writeFieldEnd() + if self.numBitVector is not None: + oprot.writeFieldBegin('numBitVector', TType.I32, 2) + oprot.writeI32(self.numBitVector) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -5733,6 +5826,7 @@ def validate(self): def __hash__(self): value = 17 value = (value * 31) ^ hash(self.colStats) + value = (value * 31) ^ hash(self.numBitVector) return value def __repr__(self): diff --git a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index 4a24a19..5e59335 100644 --- a/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -1262,9 +1262,30 @@ end class SetPartitionsStatsRequest include ::Thrift::Struct, ::Thrift::Struct_Union COLSTATS = 1 + NUMBITVECTOR = 2 FIELDS = { - COLSTATS => {:type => ::Thrift::Types::LIST, :name => 'colStats', :element => {:type => ::Thrift::Types::STRUCT, :class => ::ColumnStatistics}} + COLSTATS => {:type => ::Thrift::Types::LIST, :name => 'colStats', :element => {:type => ::Thrift::Types::STRUCT, :class => ::ColumnStatistics}}, + NUMBITVECTOR => {:type => ::Thrift::Types::I32, :name => 'numBitVector', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Required field colStats is unset!') unless @colStats + end + + ::Thrift::Struct.generate_accessors self +end + +class SetColumnStatsRequest + include ::Thrift::Struct, ::Thrift::Struct_Union + COLSTATS = 1 + NUMBITVECTOR = 2 + + FIELDS = { + COLSTATS => {:type => ::Thrift::Types::STRUCT, :name => 'colStats', :class => ::ColumnStatistics}, + NUMBITVECTOR => {:type => ::Thrift::Types::I32, :name => 'numBitVector', :optional => true} } def struct_fields; FIELDS; end diff --git a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index 99a764e..eb34020 100644 --- a/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -1414,6 +1414,25 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'update_partition_column_statistics failed: unknown result') end + def renew_column_statistics(request) + send_renew_column_statistics(request) + return recv_renew_column_statistics() + end + + def send_renew_column_statistics(request) + send_message('renew_column_statistics', Renew_column_statistics_args, :request => request) + end + + def recv_renew_column_statistics() + result = receive_message(Renew_column_statistics_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + raise result.o4 unless result.o4.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'renew_column_statistics failed: unknown result') + end + def get_table_column_statistics(db_name, tbl_name, col_name) send_get_table_column_statistics(db_name, tbl_name, col_name) return recv_get_table_column_statistics() @@ -3561,6 +3580,23 @@ module ThriftHiveMetastore write_result(result, oprot, 'update_partition_column_statistics', seqid) end + def process_renew_column_statistics(seqid, iprot, oprot) + args = read_args(iprot, Renew_column_statistics_args) + result = Renew_column_statistics_result.new() + begin + result.success = @handler.renew_column_statistics(args.request) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidObjectException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + rescue ::InvalidInputException => o4 + result.o4 = o4 + end + write_result(result, oprot, 'renew_column_statistics', seqid) + end + def process_get_table_column_statistics(seqid, iprot, oprot) args = read_args(iprot, Get_table_column_statistics_args) result = Get_table_column_statistics_result.new() @@ -7494,6 +7530,46 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Renew_column_statistics_args + include ::Thrift::Struct, ::Thrift::Struct_Union + REQUEST = 1 + + FIELDS = { + REQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'request', :class => ::SetColumnStatsRequest} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Renew_column_statistics_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + O3 = 3 + O4 = 4 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::BOOL, :name => 'success'}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException}, + O4 => {:type => ::Thrift::Types::STRUCT, :name => 'o4', :class => ::InvalidInputException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + class Get_table_column_statistics_args include ::Thrift::Struct, ::Thrift::Struct_Union DB_NAME = 1 diff --git a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index ed2057a..418ff39 100644 --- a/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -26,7 +26,6 @@ import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.Lists; import com.google.common.collect.Multimaps; - import org.apache.commons.cli.OptionBuilder; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; @@ -113,7 +112,6 @@ import org.slf4j.LoggerFactory; import javax.jdo.JDOException; - import java.io.IOException; import java.nio.ByteBuffer; import java.text.DateFormat; @@ -4339,7 +4337,9 @@ public ColumnStatistics get_table_column_statistics(String dbName, String tableN try { statsObj = getMS().getTableColumnStatistics( dbName, tableName, Lists.newArrayList(colName)); - assert statsObj.getStatsObjSize() <= 1; + if (statsObj != null) { + assert statsObj.getStatsObjSize() <= 1; + } return statsObj; } finally { endFunction("get_column_statistics_by_table: ", statsObj != null, null, tableName); @@ -5927,6 +5927,18 @@ public boolean set_aggr_stats_for(SetPartitionsStatsRequest request) } return ret; } + + @Override + public boolean renew_column_statistics(SetColumnStatsRequest request) + throws NoSuchObjectException, InvalidObjectException, MetaException, InvalidInputException, + TException { + ColumnStatistics colStats = request.getColStats(); + if (colStats.getStatsDesc().isIsTblLevel()) { + return update_table_column_statistics(colStats); + } else { + return update_partition_column_statistics(colStats); + } + } @Override public NotificationEventResponse get_next_notification(NotificationEventRequest rqst)