http://git-wip-us.apache.org/repos/asf/hive/blob/55375ec1/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 6e5de20..690c895 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 _size725; - ::apache::thrift::protocol::TType _etype728; - xfer += iprot->readListBegin(_etype728, _size725); - this->success.resize(_size725); - uint32_t _i729; - for (_i729 = 0; _i729 < _size725; ++_i729) + 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) { - xfer += iprot->readString(this->success[_i729]); + xfer += iprot->readString(this->success[_i753]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter730; - for (_iter730 = this->success.begin(); _iter730 != this->success.end(); ++_iter730) + std::vector<std::string> ::const_iterator _iter754; + for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) { - xfer += oprot->writeString((*_iter730)); + xfer += oprot->writeString((*_iter754)); } 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 _size731; - ::apache::thrift::protocol::TType _etype734; - xfer += iprot->readListBegin(_etype734, _size731); - (*(this->success)).resize(_size731); - uint32_t _i735; - for (_i735 = 0; _i735 < _size731; ++_i735) + 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) { - xfer += iprot->readString((*(this->success))[_i735]); + xfer += iprot->readString((*(this->success))[_i759]); } 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 _size736; - ::apache::thrift::protocol::TType _etype739; - xfer += iprot->readListBegin(_etype739, _size736); - this->success.resize(_size736); - uint32_t _i740; - for (_i740 = 0; _i740 < _size736; ++_i740) + 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) { - xfer += iprot->readString(this->success[_i740]); + xfer += iprot->readString(this->success[_i764]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter741; - for (_iter741 = this->success.begin(); _iter741 != this->success.end(); ++_iter741) + std::vector<std::string> ::const_iterator _iter765; + for (_iter765 = this->success.begin(); _iter765 != this->success.end(); ++_iter765) { - xfer += oprot->writeString((*_iter741)); + xfer += oprot->writeString((*_iter765)); } 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 _size742; - ::apache::thrift::protocol::TType _etype745; - xfer += iprot->readListBegin(_etype745, _size742); - (*(this->success)).resize(_size742); - uint32_t _i746; - for (_i746 = 0; _i746 < _size742; ++_i746) + 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) { - xfer += iprot->readString((*(this->success))[_i746]); + xfer += iprot->readString((*(this->success))[_i770]); } 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 _size747; - ::apache::thrift::protocol::TType _ktype748; - ::apache::thrift::protocol::TType _vtype749; - xfer += iprot->readMapBegin(_ktype748, _vtype749, _size747); - uint32_t _i751; - for (_i751 = 0; _i751 < _size747; ++_i751) + 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) { - std::string _key752; - xfer += iprot->readString(_key752); - Type& _val753 = this->success[_key752]; - xfer += _val753.read(iprot); + std::string _key776; + xfer += iprot->readString(_key776); + Type& _val777 = this->success[_key776]; + xfer += _val777.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter754; - for (_iter754 = this->success.begin(); _iter754 != this->success.end(); ++_iter754) + std::map<std::string, Type> ::const_iterator _iter778; + for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) { - xfer += oprot->writeString(_iter754->first); - xfer += _iter754->second.write(oprot); + xfer += oprot->writeString(_iter778->first); + xfer += _iter778->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 _size755; - ::apache::thrift::protocol::TType _ktype756; - ::apache::thrift::protocol::TType _vtype757; - xfer += iprot->readMapBegin(_ktype756, _vtype757, _size755); - uint32_t _i759; - for (_i759 = 0; _i759 < _size755; ++_i759) + 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) { - std::string _key760; - xfer += iprot->readString(_key760); - Type& _val761 = (*(this->success))[_key760]; - xfer += _val761.read(iprot); + std::string _key784; + xfer += iprot->readString(_key784); + Type& _val785 = (*(this->success))[_key784]; + xfer += _val785.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 _size762; - ::apache::thrift::protocol::TType _etype765; - xfer += iprot->readListBegin(_etype765, _size762); - this->success.resize(_size762); - uint32_t _i766; - for (_i766 = 0; _i766 < _size762; ++_i766) + 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) { - xfer += this->success[_i766].read(iprot); + xfer += this->success[_i790].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter767; - for (_iter767 = this->success.begin(); _iter767 != this->success.end(); ++_iter767) + std::vector<FieldSchema> ::const_iterator _iter791; + for (_iter791 = this->success.begin(); _iter791 != this->success.end(); ++_iter791) { - xfer += (*_iter767).write(oprot); + xfer += (*_iter791).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 _size768; - ::apache::thrift::protocol::TType _etype771; - xfer += iprot->readListBegin(_etype771, _size768); - (*(this->success)).resize(_size768); - uint32_t _i772; - for (_i772 = 0; _i772 < _size768; ++_i772) + 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) { - xfer += (*(this->success))[_i772].read(iprot); + xfer += (*(this->success))[_i796].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 _size773; - ::apache::thrift::protocol::TType _etype776; - xfer += iprot->readListBegin(_etype776, _size773); - this->success.resize(_size773); - uint32_t _i777; - for (_i777 = 0; _i777 < _size773; ++_i777) + 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) { - xfer += this->success[_i777].read(iprot); + xfer += this->success[_i801].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter778; - for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778) + std::vector<FieldSchema> ::const_iterator _iter802; + for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802) { - xfer += (*_iter778).write(oprot); + xfer += (*_iter802).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 _size779; - ::apache::thrift::protocol::TType _etype782; - xfer += iprot->readListBegin(_etype782, _size779); - (*(this->success)).resize(_size779); - uint32_t _i783; - for (_i783 = 0; _i783 < _size779; ++_i783) + 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) { - xfer += (*(this->success))[_i783].read(iprot); + xfer += (*(this->success))[_i807].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 _size784; - ::apache::thrift::protocol::TType _etype787; - xfer += iprot->readListBegin(_etype787, _size784); - this->success.resize(_size784); - uint32_t _i788; - for (_i788 = 0; _i788 < _size784; ++_i788) + uint32_t _size808; + ::apache::thrift::protocol::TType _etype811; + xfer += iprot->readListBegin(_etype811, _size808); + this->success.resize(_size808); + uint32_t _i812; + for (_i812 = 0; _i812 < _size808; ++_i812) { - xfer += this->success[_i788].read(iprot); + xfer += this->success[_i812].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter789; - for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789) + std::vector<FieldSchema> ::const_iterator _iter813; + for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813) { - xfer += (*_iter789).write(oprot); + xfer += (*_iter813).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 _size790; - ::apache::thrift::protocol::TType _etype793; - xfer += iprot->readListBegin(_etype793, _size790); - (*(this->success)).resize(_size790); - uint32_t _i794; - for (_i794 = 0; _i794 < _size790; ++_i794) + uint32_t _size814; + ::apache::thrift::protocol::TType _etype817; + xfer += iprot->readListBegin(_etype817, _size814); + (*(this->success)).resize(_size814); + uint32_t _i818; + for (_i818 = 0; _i818 < _size814; ++_i818) { - xfer += (*(this->success))[_i794].read(iprot); + xfer += (*(this->success))[_i818].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 _size795; - ::apache::thrift::protocol::TType _etype798; - xfer += iprot->readListBegin(_etype798, _size795); - this->success.resize(_size795); - uint32_t _i799; - for (_i799 = 0; _i799 < _size795; ++_i799) + uint32_t _size819; + ::apache::thrift::protocol::TType _etype822; + xfer += iprot->readListBegin(_etype822, _size819); + this->success.resize(_size819); + uint32_t _i823; + for (_i823 = 0; _i823 < _size819; ++_i823) { - xfer += this->success[_i799].read(iprot); + xfer += this->success[_i823].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter800; - for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800) + std::vector<FieldSchema> ::const_iterator _iter824; + for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824) { - xfer += (*_iter800).write(oprot); + xfer += (*_iter824).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 _size801; - ::apache::thrift::protocol::TType _etype804; - xfer += iprot->readListBegin(_etype804, _size801); - (*(this->success)).resize(_size801); - uint32_t _i805; - for (_i805 = 0; _i805 < _size801; ++_i805) + uint32_t _size825; + ::apache::thrift::protocol::TType _etype828; + xfer += iprot->readListBegin(_etype828, _size825); + (*(this->success)).resize(_size825); + uint32_t _i829; + for (_i829 = 0; _i829 < _size825; ++_i829) { - xfer += (*(this->success))[_i805].read(iprot); + xfer += (*(this->success))[_i829].read(iprot); } xfer += iprot->readListEnd(); } @@ -4481,11 +4481,11 @@ uint32_t ThriftHiveMetastore_create_table_with_environment_context_presult::read } -ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { +ThriftHiveMetastore_create_table_with_constraints_args::~ThriftHiveMetastore_create_table_with_constraints_args() throw() { } -uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4507,25 +4507,49 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->dbname); - this->__isset.dbname = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->tbl.read(iprot); + this->__isset.tbl = true; } else { xfer += iprot->skip(ftype); } break; case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->name); - this->__isset.name = true; + if (ftype == ::apache::thrift::protocol::T_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) + { + xfer += this->primaryKeys[_i834].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.primaryKeys = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->deleteData); - this->__isset.deleteData = true; + 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) + { + xfer += this->foreignKeys[_i839].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.foreignKeys = true; } else { xfer += iprot->skip(ftype); } @@ -4542,21 +4566,37 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_args"); - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->dbname); + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->tbl.write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); + std::vector<SQLPrimaryKey> ::const_iterator _iter840; + for (_iter840 = this->primaryKeys.begin(); _iter840 != this->primaryKeys.end(); ++_iter840) + { + xfer += (*_iter840).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); + std::vector<SQLForeignKey> ::const_iterator _iter841; + for (_iter841 = this->foreignKeys.begin(); _iter841 != this->foreignKeys.end(); ++_iter841) + { + xfer += (*_iter841).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -4565,25 +4605,41 @@ uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { +ThriftHiveMetastore_create_table_with_constraints_pargs::~ThriftHiveMetastore_create_table_with_constraints_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_pargs"); - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->dbname))); + xfer += oprot->writeFieldBegin("tbl", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->tbl)).write(oprot); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size())); + std::vector<SQLPrimaryKey> ::const_iterator _iter842; + for (_iter842 = (*(this->primaryKeys)).begin(); _iter842 != (*(this->primaryKeys)).end(); ++_iter842) + { + xfer += (*_iter842).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size())); + std::vector<SQLForeignKey> ::const_iterator _iter843; + for (_iter843 = (*(this->foreignKeys)).begin(); _iter843 != (*(this->foreignKeys)).end(); ++_iter843) + { + xfer += (*_iter843).write(oprot); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -4592,11 +4648,11 @@ uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { +ThriftHiveMetastore_create_table_with_constraints_result::~ThriftHiveMetastore_create_table_with_constraints_result() throw() { } -uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_table_with_constraints_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4627,12 +4683,28 @@ uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol: 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; @@ -4645,20 +4717,28 @@ uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_create_table_with_constraints_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_create_table_with_constraints_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); } else if (this->__isset.o3) { - xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + 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(); @@ -4666,11 +4746,11 @@ uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_drop_table_presult::~ThriftHiveMetastore_drop_table_presult() throw() { +ThriftHiveMetastore_create_table_with_constraints_presult::~ThriftHiveMetastore_create_table_with_constraints_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_create_table_with_constraints_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4701,12 +4781,28 @@ uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol 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; @@ -4720,11 +4816,11 @@ uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_drop_table_with_environment_context_args::~ThriftHiveMetastore_drop_table_with_environment_context_args() throw() { +ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4769,14 +4865,6 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::ap xfer += iprot->skip(ftype); } break; - case 4: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->environment_context.read(iprot); - this->__isset.environment_context = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -4789,10 +4877,10 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::ap return xfer; } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->dbname); @@ -4806,24 +4894,20 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::a xfer += oprot->writeBool(this->deleteData); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); - xfer += this->environment_context.write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_drop_table_with_environment_context_pargs::~ThriftHiveMetastore_drop_table_with_environment_context_pargs() throw() { +ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->dbname))); @@ -4837,21 +4921,17 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(:: xfer += oprot->writeBool((*(this->deleteData))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); - xfer += (*(this->environment_context)).write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_drop_table_with_environment_context_result::~ThriftHiveMetastore_drop_table_with_environment_context_result() throw() { +ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4900,11 +4980,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(:: return xfer; } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -4921,11 +5001,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(: } -ThriftHiveMetastore_drop_table_with_environment_context_presult::~ThriftHiveMetastore_drop_table_with_environment_context_presult() throw() { +ThriftHiveMetastore_drop_table_presult::~ThriftHiveMetastore_drop_table_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4975,11 +5055,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(: } -ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_args::~ThriftHiveMetastore_drop_table_with_environment_context_args() throw() { } -uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5002,16 +5082,32 @@ uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::T { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->db_name); - this->__isset.db_name = true; + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->pattern); - this->__isset.pattern = true; + xfer += iprot->readString(this->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; } else { xfer += iprot->skip(ftype); } @@ -5028,17 +5124,25 @@ uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args"); - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5047,21 +5151,29 @@ uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_get_tables_pargs::~ThriftHiveMetastore_get_tables_pargs() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_pargs::~ThriftHiveMetastore_drop_table_with_environment_context_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs"); - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5070,11 +5182,234 @@ uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_get_tables_result::~ThriftHiveMetastore_get_tables_result() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_result::~ThriftHiveMetastore_drop_table_with_environment_context_result() throw() { } -uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_drop_table_with_environment_context_presult::~ThriftHiveMetastore_drop_table_with_environment_context_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { + + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; + + xfer += iprot->readStructBegin(fname); + + using ::apache::thrift::protocol::TProtocolException; + + + while (true) + { + xfer += iprot->readFieldBegin(fname, ftype, fid); + if (ftype == ::apache::thrift::protocol::T_STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_args"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_pargs::~ThriftHiveMetastore_get_tables_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_pargs"); + + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_result::~ThriftHiveMetastore_get_tables_result() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5099,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 _size806; - ::apache::thrift::protocol::TType _etype809; - xfer += iprot->readListBegin(_etype809, _size806); - this->success.resize(_size806); - uint32_t _i810; - for (_i810 = 0; _i810 < _size806; ++_i810) + 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) { - xfer += iprot->readString(this->success[_i810]); + xfer += iprot->readString(this->success[_i848]); } xfer += iprot->readListEnd(); } @@ -5145,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter811; - for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811) + std::vector<std::string> ::const_iterator _iter849; + for (_iter849 = this->success.begin(); _iter849 != this->success.end(); ++_iter849) { - xfer += oprot->writeString((*_iter811)); + xfer += oprot->writeString((*_iter849)); } xfer += oprot->writeListEnd(); } @@ -5193,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 _size812; - ::apache::thrift::protocol::TType _etype815; - xfer += iprot->readListBegin(_etype815, _size812); - (*(this->success)).resize(_size812); - uint32_t _i816; - for (_i816 = 0; _i816 < _size812; ++_i816) + uint32_t _size850; + ::apache::thrift::protocol::TType _etype853; + xfer += iprot->readListBegin(_etype853, _size850); + (*(this->success)).resize(_size850); + uint32_t _i854; + for (_i854 = 0; _i854 < _size850; ++_i854) { - xfer += iprot->readString((*(this->success))[_i816]); + xfer += iprot->readString((*(this->success))[_i854]); } xfer += iprot->readListEnd(); } @@ -5275,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 _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->tbl_types.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + 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) { - xfer += iprot->readString(this->tbl_types[_i821]); + xfer += iprot->readString(this->tbl_types[_i859]); } xfer += iprot->readListEnd(); } @@ -5319,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<uint32_t>(this->tbl_types.size())); - std::vector<std::string> ::const_iterator _iter822; - for (_iter822 = this->tbl_types.begin(); _iter822 != this->tbl_types.end(); ++_iter822) + std::vector<std::string> ::const_iterator _iter860; + for (_iter860 = this->tbl_types.begin(); _iter860 != this->tbl_types.end(); ++_iter860) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter860)); } xfer += oprot->writeListEnd(); } @@ -5354,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<uint32_t>((*(this->tbl_types)).size())); - std::vector<std::string> ::const_iterator _iter823; - for (_iter823 = (*(this->tbl_types)).begin(); _iter823 != (*(this->tbl_types)).end(); ++_iter823) + std::vector<std::string> ::const_iterator _iter861; + for (_iter861 = (*(this->tbl_types)).begin(); _iter861 != (*(this->tbl_types)).end(); ++_iter861) { - xfer += oprot->writeString((*_iter823)); + xfer += oprot->writeString((*_iter861)); } xfer += oprot->writeListEnd(); } @@ -5398,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 _size824; - ::apache::thrift::protocol::TType _etype827; - xfer += iprot->readListBegin(_etype827, _size824); - this->success.resize(_size824); - uint32_t _i828; - for (_i828 = 0; _i828 < _size824; ++_i828) + 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) { - xfer += this->success[_i828].read(iprot); + xfer += this->success[_i866].read(iprot); } xfer += iprot->readListEnd(); } @@ -5444,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<uint32_t>(this->success.size())); - std::vector<TableMeta> ::const_iterator _iter829; - for (_iter829 = this->success.begin(); _iter829 != this->success.end(); ++_iter829) + std::vector<TableMeta> ::const_iterator _iter867; + for (_iter867 = this->success.begin(); _iter867 != this->success.end(); ++_iter867) { - xfer += (*_iter829).write(oprot); + xfer += (*_iter867).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5492,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 _size830; - ::apache::thrift::protocol::TType _etype833; - xfer += iprot->readListBegin(_etype833, _size830); - (*(this->success)).resize(_size830); - uint32_t _i834; - for (_i834 = 0; _i834 < _size830; ++_i834) + uint32_t _size868; + ::apache::thrift::protocol::TType _etype871; + xfer += iprot->readListBegin(_etype871, _size868); + (*(this->success)).resize(_size868); + uint32_t _i872; + for (_i872 = 0; _i872 < _size868; ++_i872) { - xfer += (*(this->success))[_i834].read(iprot); + xfer += (*(this->success))[_i872].read(iprot); } xfer += iprot->readListEnd(); } @@ -5637,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 _size835; - ::apache::thrift::protocol::TType _etype838; - xfer += iprot->readListBegin(_etype838, _size835); - this->success.resize(_size835); - uint32_t _i839; - for (_i839 = 0; _i839 < _size835; ++_i839) + 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) { - xfer += iprot->readString(this->success[_i839]); + xfer += iprot->readString(this->success[_i877]); } xfer += iprot->readListEnd(); } @@ -5683,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter840; - for (_iter840 = this->success.begin(); _iter840 != this->success.end(); ++_iter840) + std::vector<std::string> ::const_iterator _iter878; + for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878) { - xfer += oprot->writeString((*_iter840)); + xfer += oprot->writeString((*_iter878)); } xfer += oprot->writeListEnd(); } @@ -5731,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 _size841; - ::apache::thrift::protocol::TType _etype844; - xfer += iprot->readListBegin(_etype844, _size841); - (*(this->success)).resize(_size841); - uint32_t _i845; - for (_i845 = 0; _i845 < _size841; ++_i845) + uint32_t _size879; + ::apache::thrift::protocol::TType _etype882; + xfer += iprot->readListBegin(_etype882, _size879); + (*(this->success)).resize(_size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - xfer += iprot->readString((*(this->success))[_i845]); + xfer += iprot->readString((*(this->success))[_i883]); } xfer += iprot->readListEnd(); } @@ -6048,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 _size846; - ::apache::thrift::protocol::TType _etype849; - xfer += iprot->readListBegin(_etype849, _size846); - this->tbl_names.resize(_size846); - uint32_t _i850; - for (_i850 = 0; _i850 < _size846; ++_i850) + 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) { - xfer += iprot->readString(this->tbl_names[_i850]); + xfer += iprot->readString(this->tbl_names[_i888]); } xfer += iprot->readListEnd(); } @@ -6088,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<uint32_t>(this->tbl_names.size())); - std::vector<std::string> ::const_iterator _iter851; - for (_iter851 = this->tbl_names.begin(); _iter851 != this->tbl_names.end(); ++_iter851) + std::vector<std::string> ::const_iterator _iter889; + for (_iter889 = this->tbl_names.begin(); _iter889 != this->tbl_names.end(); ++_iter889) { - xfer += oprot->writeString((*_iter851)); + xfer += oprot->writeString((*_iter889)); } xfer += oprot->writeListEnd(); } @@ -6119,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<uint32_t>((*(this->tbl_names)).size())); - std::vector<std::string> ::const_iterator _iter852; - for (_iter852 = (*(this->tbl_names)).begin(); _iter852 != (*(this->tbl_names)).end(); ++_iter852) + std::vector<std::string> ::const_iterator _iter890; + for (_iter890 = (*(this->tbl_names)).begin(); _iter890 != (*(this->tbl_names)).end(); ++_iter890) { - xfer += oprot->writeString((*_iter852)); + xfer += oprot->writeString((*_iter890)); } xfer += oprot->writeListEnd(); } @@ -6163,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 _size853; - ::apache::thrift::protocol::TType _etype856; - xfer += iprot->readListBegin(_etype856, _size853); - this->success.resize(_size853); - uint32_t _i857; - for (_i857 = 0; _i857 < _size853; ++_i857) + 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) { - xfer += this->success[_i857].read(iprot); + xfer += this->success[_i895].read(iprot); } xfer += iprot->readListEnd(); } @@ -6225,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<uint32_t>(this->success.size())); - std::vector<Table> ::const_iterator _iter858; - for (_iter858 = this->success.begin(); _iter858 != this->success.end(); ++_iter858) + std::vector<Table> ::const_iterator _iter896; + for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896) { - xfer += (*_iter858).write(oprot); + xfer += (*_iter896).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6281,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 _size859; - ::apache::thrift::protocol::TType _etype862; - xfer += iprot->readListBegin(_etype862, _size859); - (*(this->success)).resize(_size859); - uint32_t _i863; - for (_i863 = 0; _i863 < _size859; ++_i863) + uint32_t _size897; + ::apache::thrift::protocol::TType _etype900; + xfer += iprot->readListBegin(_etype900, _size897); + (*(this->success)).resize(_size897); + uint32_t _i901; + for (_i901 = 0; _i901 < _size897; ++_i901) { - xfer += (*(this->success))[_i863].read(iprot); + xfer += (*(this->success))[_i901].read(iprot); } xfer += iprot->readListEnd(); } @@ -6474,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 _size864; - ::apache::thrift::protocol::TType _etype867; - xfer += iprot->readListBegin(_etype867, _size864); - this->success.resize(_size864); - uint32_t _i868; - for (_i868 = 0; _i868 < _size864; ++_i868) + 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) { - xfer += iprot->readString(this->success[_i868]); + xfer += iprot->readString(this->success[_i906]); } xfer += iprot->readListEnd(); } @@ -6536,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<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter869; - for (_iter869 = this->success.begin(); _iter869 != this->success.end(); ++_iter869) + std::vector<std::string> ::const_iterator _iter907; + for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907) { - xfer += oprot->writeString((*_iter869)); + xfer += oprot->writeString((*_iter907)); } xfer += oprot->writeListEnd(); } @@ -6592,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 _size870; - ::apache::thrift::protocol::TType _etype873; - xfer += iprot->readListBegin(_etype873, _size870); - (*(this->success)).resize(_size870); - uint32_t _i874; - for (_i874 = 0; _i874 < _size870; ++_i874) + uint32_t _size908; + ::apache::thrift::protocol::TType _etype911; + xfer += iprot->readListBegin(_etype911, _size908); + (*(this->success)).resize(_size908); + uint32_t _i912; + for (_i912 = 0; _i912 < _size908; ++_i912) { - xfer += iprot->readString((*(this->success))[_i874]); + xfer += iprot->readString((*(this->success))[_i912]); } xfer += iprot->readListEnd(); } @@ -7933,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 _size875; - ::apache::thrift::protocol::TType _etype878; - xfer += iprot->readListBegin(_etype878, _size875); - this->new_parts.resize(_size875); - uint32_t _i879; - for (_i879 = 0; _i879 < _size875; ++_i879) + 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) { - xfer += this->new_parts[_i879].read(iprot); + xfer += this->new_parts[_i917].read(iprot); } xfer += iprot->readListEnd(); } @@ -7969,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<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter880; - for (_iter880 = this->new_parts.begin(); _iter880 != this->new_parts.end(); ++_iter880) + std::vector<Partition> ::const_iterator _iter918; + for (_iter918 = this->new_parts.begin(); _iter918 != this->new_parts.end(); ++_iter918) { - xfer += (*_iter880).write(oprot); + xfer += (*_iter918).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7996,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<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter881; - for (_iter881 = (*(this->new_parts)).begin(); _iter881 != (*(this->new_parts)).end(); ++_iter881) + std::vector<Partition> ::const_iterator _iter919; + for (_iter919 = (*(this->new_parts)).begin(); _iter919 != (*(this->new_parts)).end(); ++_iter919) { - xfer += (*_iter881).write(oprot); + xfer += (*_iter919).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8208,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 _size882; - ::apache::thrift::protocol::TType _etype885; - xfer += iprot->readListBegin(_etype885, _size882); - this->new_parts.resize(_size882); - uint32_t _i886; - for (_i886 = 0; _i886 < _size882; ++_i886) + 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) { - xfer += this->new_parts[_i886].read(iprot); + xfer += this->new_parts[_i924].read(iprot); } xfer += iprot->readListEnd(); } @@ -8244,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<uint32_t>(this->new_parts.size())); - std::vector<PartitionSpec> ::const_iterator _iter887; - for (_iter887 = this->new_parts.begin(); _iter887 != this->new_parts.end(); ++_iter887) + std::vector<PartitionSpec> ::const_iterator _iter925; + for (_iter925 = this->new_parts.begin(); _iter925 != this->new_parts.end(); ++_iter925) { - xfer += (*_iter887).write(oprot); + xfer += (*_iter925).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8271,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<uint32_t>((*(this->new_parts)).size())); - std::vector<PartitionSpec> ::const_iterator _iter888; - for (_iter888 = (*(this->new_parts)).begin(); _iter888 != (*(this->new_parts)).end(); ++_iter888) + std::vector<PartitionSpec> ::const_iterator _iter926; + for (_iter926 = (*(this->new_parts)).begin(); _iter926 != (*(this->new_parts)).end(); ++_iter926) { - xfer += (*_iter888).write(oprot); + xfer += (*_iter926).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8499,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 _size889; - ::apache::thrift::protocol::TType _etype892; - xfer += iprot->readListBegin(_etype892, _size889); - this->part_vals.resize(_size889); - uint32_t _i893; - for (_i893 = 0; _i893 < _size889; ++_i893) + 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) { - xfer += iprot->readString(this->part_vals[_i893]); + xfer += iprot->readString(this->part_vals[_i931]); } xfer += iprot->readListEnd(); } @@ -8543,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter894; - for (_iter894 = this->part_vals.begin(); _iter894 != this->part_vals.end(); ++_iter894) + std::vector<std::string> ::const_iterator _iter932; + for (_iter932 = this->part_vals.begin(); _iter932 != this->part_vals.end(); ++_iter932) { - xfer += oprot->writeString((*_iter894)); + xfer += oprot->writeString((*_iter932)); } xfer += oprot->writeListEnd(); } @@ -8578,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter895; - for (_iter895 = (*(this->part_vals)).begin(); _iter895 != (*(this->part_vals)).end(); ++_iter895) + std::vector<std::string> ::const_iterator _iter933; + for (_iter933 = (*(this->part_vals)).begin(); _iter933 != (*(this->part_vals)).end(); ++_iter933) { - xfer += oprot->writeString((*_iter895)); + xfer += oprot->writeString((*_iter933)); } xfer += oprot->writeListEnd(); } @@ -9053,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 _size896; - ::apache::thrift::protocol::TType _etype899; - xfer += iprot->readListBegin(_etype899, _size896); - this->part_vals.resize(_size896); - uint32_t _i900; - for (_i900 = 0; _i900 < _size896; ++_i900) + 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) { - xfer += iprot->readString(this->part_vals[_i900]); + xfer += iprot->readString(this->part_vals[_i938]); } xfer += iprot->readListEnd(); } @@ -9105,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter901; - for (_iter901 = this->part_vals.begin(); _iter901 != this->part_vals.end(); ++_iter901) + std::vector<std::string> ::const_iterator _iter939; + for (_iter939 = this->part_vals.begin(); _iter939 != this->part_vals.end(); ++_iter939) { - xfer += oprot->writeString((*_iter901)); + xfer += oprot->writeString((*_iter939)); } xfer += oprot->writeListEnd(); } @@ -9144,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter902; - for (_iter902 = (*(this->part_vals)).begin(); _iter902 != (*(this->part_vals)).end(); ++_iter902) + std::vector<std::string> ::const_iterator _iter940; + for (_iter940 = (*(this->part_vals)).begin(); _iter940 != (*(this->part_vals)).end(); ++_iter940) { - xfer += oprot->writeString((*_iter902)); + xfer += oprot->writeString((*_iter940)); } xfer += oprot->writeListEnd(); } @@ -9950,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 _size903; - ::apache::thrift::protocol::TType _etype906; - xfer += iprot->readListBegin(_etype906, _size903); - this->part_vals.resize(_size903); - uint32_t _i907; - for (_i907 = 0; _i907 < _size903; ++_i907) + 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) { - xfer += iprot->readString(this->part_vals[_i907]); + xfer += iprot->readString(this->part_vals[_i945]); } xfer += iprot->readListEnd(); } @@ -10002,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter908; - for (_iter908 = this->part_vals.begin(); _iter908 != this->part_vals.end(); ++_iter908) + std::vector<std::string> ::const_iterator _iter946; + for (_iter946 = this->part_vals.begin(); _iter946 != this->part_vals.end(); ++_iter946) { - xfer += oprot->writeString((*_iter908)); + xfer += oprot->writeString((*_iter946)); } xfer += oprot->writeListEnd(); } @@ -10041,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter909; - for (_iter909 = (*(this->part_vals)).begin(); _iter909 != (*(this->part_vals)).end(); ++_iter909) + std::vector<std::string> ::const_iterator _iter947; + for (_iter947 = (*(this->part_vals)).begin(); _iter947 != (*(this->part_vals)).end(); ++_iter947) { - xfer += oprot->writeString((*_iter909)); + xfer += oprot->writeString((*_iter947)); } xfer += oprot->writeListEnd(); } @@ -10253,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 _size910; - ::apache::thrift::protocol::TType _etype913; - xfer += iprot->readListBegin(_etype913, _size910); - this->part_vals.resize(_size910); - uint32_t _i914; - for (_i914 = 0; _i914 < _size910; ++_i914) + 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) { - xfer += iprot->readString(this->part_vals[_i914]); + xfer += iprot->readString(this->part_vals[_i952]); } xfer += iprot->readListEnd(); } @@ -10313,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter915; - for (_iter915 = this->part_vals.begin(); _iter915 != this->part_vals.end(); ++_iter915) + std::vector<std::string> ::const_iterator _iter953; + for (_iter953 = this->part_vals.begin(); _iter953 != this->part_vals.end(); ++_iter953) { - xfer += oprot->writeString((*_iter915)); + xfer += oprot->writeString((*_iter953)); } xfer += oprot->writeListEnd(); } @@ -10356,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter916; - for (_iter916 = (*(this->part_vals)).begin(); _iter916 != (*(this->part_vals)).end(); ++_iter916) + std::vector<std::string> ::const_iterator _iter954; + for (_iter954 = (*(this->part_vals)).begin(); _iter954 != (*(this->part_vals)).end(); ++_iter954) { - xfer += oprot->writeString((*_iter916)); + xfer += oprot->writeString((*_iter954)); } xfer += oprot->writeListEnd(); } @@ -11365,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 _size917; - ::apache::thrift::protocol::TType _etype920; - xfer += iprot->readListBegin(_etype920, _size917); - this->part_vals.resize(_size917); - uint32_t _i921; - for (_i921 = 0; _i921 < _size917; ++_i921) + 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) { - xfer += iprot->readString(this->part_vals[_i921]); + xfer += iprot->readString(this->part_vals[_i959]); } xfer += iprot->readListEnd(); } @@ -11409,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<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter922; - for (_iter922 = this->part_vals.begin(); _iter922 != this->part_vals.end(); ++_iter922) + std::vector<std::string> ::const_iterator _iter960; + for (_iter960 = this->part_vals.begin(); _iter960 != this->part_vals.end(); ++_iter960) { - xfer += oprot->writeString((*_iter922)); + xfer += oprot->writeString((*_iter960)); } xfer += oprot->writeListEnd(); } @@ -11444,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<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter923; - for (_iter923 = (*(this->part_vals)).begin(); _iter923 != (*(this->part_vals)).end(); ++_iter923) + std::vector<std::string> ::const_iterator _iter961; + for (_iter961 = (*(this->part_vals)).begin(); _iter961 != (*(this->part_vals)).end(); ++_iter961) { - xfer += oprot->writeString((*_iter923)); + xfer += oprot->writeString((*_iter961)); } xfer += oprot->writeListEnd(); } @@ -11636,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 _size924; - ::apache::thrift::protocol::TType _ktype925; - ::apache::thrift::protocol::TType _vtype926; - xfer += iprot->readMapBegin(_ktype925, _vtype926, _size924); - uint32_t _i928; - for (_i928 = 0; _i928 < _size924; ++_i928) + 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) { - std::string _key929; - xfer += iprot->readString(_key929); - std::string& _val930 = this->partitionSpecs[_key929]; - xfer += iprot->readString(_val930); + std::string _key967; + xfer += iprot->readString(_key967); + std::string& _val968 = this->partitionSpecs[_key967]; + xfer += iprot->readString(_val968); } xfer += iprot->readMapEnd(); } @@ -11707,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
<TRUNCATED>
