Grokbase Groups Hive commits May 2016
FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/6c4c6369/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 29d9ec4..0440df7 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 _size747;
- ::apache::thrift::protocol::TType _etype750;
- xfer += iprot->readListBegin(_etype750, _size747);
- this->success.resize(_size747);
- uint32_t _i751;
- for (_i751 = 0; _i751 < _size747; ++_i751)
+ 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[_i751]);
+ xfer += iprot->readString(this->success[_i759]);
              }
              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 _iter752;
- for (_iter752 = this->success.begin(); _iter752 != this->success.end(); ++_iter752)
+ std::vector<std::string> ::const_iterator _iter760;
+ for (_iter760 = this->success.begin(); _iter760 != this->success.end(); ++_iter760)
        {
- xfer += oprot->writeString((*_iter752));
+ xfer += oprot->writeString((*_iter760));
        }
        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 _size753;
- ::apache::thrift::protocol::TType _etype756;
- xfer += iprot->readListBegin(_etype756, _size753);
- (*(this->success)).resize(_size753);
- uint32_t _i757;
- for (_i757 = 0; _i757 < _size753; ++_i757)
+ uint32_t _size761;
+ ::apache::thrift::protocol::TType _etype764;
+ xfer += iprot->readListBegin(_etype764, _size761);
+ (*(this->success)).resize(_size761);
+ uint32_t _i765;
+ for (_i765 = 0; _i765 < _size761; ++_i765)
              {
- xfer += iprot->readString((*(this->success))[_i757]);
+ xfer += iprot->readString((*(this->success))[_i765]);
              }
              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 _size758;
- ::apache::thrift::protocol::TType _etype761;
- xfer += iprot->readListBegin(_etype761, _size758);
- this->success.resize(_size758);
- uint32_t _i762;
- for (_i762 = 0; _i762 < _size758; ++_i762)
+ 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[_i762]);
+ xfer += iprot->readString(this->success[_i770]);
              }
              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 _iter763;
- for (_iter763 = this->success.begin(); _iter763 != this->success.end(); ++_iter763)
+ std::vector<std::string> ::const_iterator _iter771;
+ for (_iter771 = this->success.begin(); _iter771 != this->success.end(); ++_iter771)
        {
- xfer += oprot->writeString((*_iter763));
+ xfer += oprot->writeString((*_iter771));
        }
        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 _size764;
- ::apache::thrift::protocol::TType _etype767;
- xfer += iprot->readListBegin(_etype767, _size764);
- (*(this->success)).resize(_size764);
- uint32_t _i768;
- for (_i768 = 0; _i768 < _size764; ++_i768)
+ uint32_t _size772;
+ ::apache::thrift::protocol::TType _etype775;
+ xfer += iprot->readListBegin(_etype775, _size772);
+ (*(this->success)).resize(_size772);
+ uint32_t _i776;
+ for (_i776 = 0; _i776 < _size772; ++_i776)
              {
- xfer += iprot->readString((*(this->success))[_i768]);
+ xfer += iprot->readString((*(this->success))[_i776]);
              }
              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 _size769;
- ::apache::thrift::protocol::TType _ktype770;
- ::apache::thrift::protocol::TType _vtype771;
- xfer += iprot->readMapBegin(_ktype770, _vtype771, _size769);
- uint32_t _i773;
- for (_i773 = 0; _i773 < _size769; ++_i773)
+ uint32_t _size777;
+ ::apache::thrift::protocol::TType _ktype778;
+ ::apache::thrift::protocol::TType _vtype779;
+ xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777);
+ uint32_t _i781;
+ for (_i781 = 0; _i781 < _size777; ++_i781)
              {
- std::string _key774;
- xfer += iprot->readString(_key774);
- Type& _val775 = this->success[_key774];
- xfer += _val775.read(iprot);
+ std::string _key782;
+ xfer += iprot->readString(_key782);
+ Type& _val783 = this->success[_key782];
+ xfer += _val783.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 _iter776;
- for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776)
+ std::map<std::string, Type> ::const_iterator _iter784;
+ for (_iter784 = this->success.begin(); _iter784 != this->success.end(); ++_iter784)
        {
- xfer += oprot->writeString(_iter776->first);
- xfer += _iter776->second.write(oprot);
+ xfer += oprot->writeString(_iter784->first);
+ xfer += _iter784->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 _size777;
- ::apache::thrift::protocol::TType _ktype778;
- ::apache::thrift::protocol::TType _vtype779;
- xfer += iprot->readMapBegin(_ktype778, _vtype779, _size777);
- uint32_t _i781;
- for (_i781 = 0; _i781 < _size777; ++_i781)
+ uint32_t _size785;
+ ::apache::thrift::protocol::TType _ktype786;
+ ::apache::thrift::protocol::TType _vtype787;
+ xfer += iprot->readMapBegin(_ktype786, _vtype787, _size785);
+ uint32_t _i789;
+ for (_i789 = 0; _i789 < _size785; ++_i789)
              {
- std::string _key782;
- xfer += iprot->readString(_key782);
- Type& _val783 = (*(this->success))[_key782];
- xfer += _val783.read(iprot);
+ std::string _key790;
+ xfer += iprot->readString(_key790);
+ Type& _val791 = (*(this->success))[_key790];
+ xfer += _val791.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 _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 _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[_i788].read(iprot);
+ xfer += this->success[_i796].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 _iter789;
- for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789)
+ std::vector<FieldSchema> ::const_iterator _iter797;
+ for (_iter797 = this->success.begin(); _iter797 != this->success.end(); ++_iter797)
        {
- xfer += (*_iter789).write(oprot);
+ xfer += (*_iter797).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 _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 _size798;
+ ::apache::thrift::protocol::TType _etype801;
+ xfer += iprot->readListBegin(_etype801, _size798);
+ (*(this->success)).resize(_size798);
+ uint32_t _i802;
+ for (_i802 = 0; _i802 < _size798; ++_i802)
              {
- xfer += (*(this->success))[_i794].read(iprot);
+ xfer += (*(this->success))[_i802].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 _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 _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[_i799].read(iprot);
+ xfer += this->success[_i807].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 _iter800;
- for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800)
+ std::vector<FieldSchema> ::const_iterator _iter808;
+ for (_iter808 = this->success.begin(); _iter808 != this->success.end(); ++_iter808)
        {
- xfer += (*_iter800).write(oprot);
+ xfer += (*_iter808).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 _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 _size809;
+ ::apache::thrift::protocol::TType _etype812;
+ xfer += iprot->readListBegin(_etype812, _size809);
+ (*(this->success)).resize(_size809);
+ uint32_t _i813;
+ for (_i813 = 0; _i813 < _size809; ++_i813)
              {
- xfer += (*(this->success))[_i805].read(iprot);
+ xfer += (*(this->success))[_i813].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 _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 _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[_i810].read(iprot);
+ xfer += this->success[_i818].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 _iter811;
- for (_iter811 = this->success.begin(); _iter811 != this->success.end(); ++_iter811)
+ std::vector<FieldSchema> ::const_iterator _iter819;
+ for (_iter819 = this->success.begin(); _iter819 != this->success.end(); ++_iter819)
        {
- xfer += (*_iter811).write(oprot);
+ xfer += (*_iter819).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 _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 _size820;
+ ::apache::thrift::protocol::TType _etype823;
+ xfer += iprot->readListBegin(_etype823, _size820);
+ (*(this->success)).resize(_size820);
+ uint32_t _i824;
+ for (_i824 = 0; _i824 < _size820; ++_i824)
              {
- xfer += (*(this->success))[_i816].read(iprot);
+ xfer += (*(this->success))[_i824].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 _size817;
- ::apache::thrift::protocol::TType _etype820;
- xfer += iprot->readListBegin(_etype820, _size817);
- this->success.resize(_size817);
- uint32_t _i821;
- for (_i821 = 0; _i821 < _size817; ++_i821)
+ 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[_i821].read(iprot);
+ xfer += this->success[_i829].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 _iter822;
- for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822)
+ std::vector<FieldSchema> ::const_iterator _iter830;
+ for (_iter830 = this->success.begin(); _iter830 != this->success.end(); ++_iter830)
        {
- xfer += (*_iter822).write(oprot);
+ xfer += (*_iter830).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 _size823;
- ::apache::thrift::protocol::TType _etype826;
- xfer += iprot->readListBegin(_etype826, _size823);
- (*(this->success)).resize(_size823);
- uint32_t _i827;
- for (_i827 = 0; _i827 < _size823; ++_i827)
+ uint32_t _size831;
+ ::apache::thrift::protocol::TType _etype834;
+ xfer += iprot->readListBegin(_etype834, _size831);
+ (*(this->success)).resize(_size831);
+ uint32_t _i835;
+ for (_i835 = 0; _i835 < _size831; ++_i835)
              {
- xfer += (*(this->success))[_i827].read(iprot);
+ xfer += (*(this->success))[_i835].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 _size828;
- ::apache::thrift::protocol::TType _etype831;
- xfer += iprot->readListBegin(_etype831, _size828);
- this->primaryKeys.resize(_size828);
- uint32_t _i832;
- for (_i832 = 0; _i832 < _size828; ++_i832)
+ uint32_t _size836;
+ ::apache::thrift::protocol::TType _etype839;
+ xfer += iprot->readListBegin(_etype839, _size836);
+ this->primaryKeys.resize(_size836);
+ uint32_t _i840;
+ for (_i840 = 0; _i840 < _size836; ++_i840)
              {
- xfer += this->primaryKeys[_i832].read(iprot);
+ xfer += this->primaryKeys[_i840].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 _size833;
- ::apache::thrift::protocol::TType _etype836;
- xfer += iprot->readListBegin(_etype836, _size833);
- this->foreignKeys.resize(_size833);
- uint32_t _i837;
- for (_i837 = 0; _i837 < _size833; ++_i837)
+ uint32_t _size841;
+ ::apache::thrift::protocol::TType _etype844;
+ xfer += iprot->readListBegin(_etype844, _size841);
+ this->foreignKeys.resize(_size841);
+ uint32_t _i845;
+ for (_i845 = 0; _i845 < _size841; ++_i845)
              {
- xfer += this->foreignKeys[_i837].read(iprot);
+ xfer += this->foreignKeys[_i845].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -4578,10 +4578,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
    xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter838;
- for (_iter838 = this->primaryKeys.begin(); _iter838 != this->primaryKeys.end(); ++_iter838)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter846;
+ for (_iter846 = this->primaryKeys.begin(); _iter846 != this->primaryKeys.end(); ++_iter846)
      {
- xfer += (*_iter838).write(oprot);
+ xfer += (*_iter846).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4590,10 +4590,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
    xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter839;
- for (_iter839 = this->foreignKeys.begin(); _iter839 != this->foreignKeys.end(); ++_iter839)
+ std::vector<SQLForeignKey> ::const_iterator _iter847;
+ for (_iter847 = this->foreignKeys.begin(); _iter847 != this->foreignKeys.end(); ++_iter847)
      {
- xfer += (*_iter839).write(oprot);
+ xfer += (*_iter847).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4621,10 +4621,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
    xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter840;
- for (_iter840 = (*(this->primaryKeys)).begin(); _iter840 != (*(this->primaryKeys)).end(); ++_iter840)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter848;
+ for (_iter848 = (*(this->primaryKeys)).begin(); _iter848 != (*(this->primaryKeys)).end(); ++_iter848)
      {
- xfer += (*_iter840).write(oprot);
+ xfer += (*_iter848).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4633,10 +4633,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
    xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size()));
- std::vector<SQLForeignKey> ::const_iterator _iter841;
- for (_iter841 = (*(this->foreignKeys)).begin(); _iter841 != (*(this->foreignKeys)).end(); ++_iter841)
+ std::vector<SQLForeignKey> ::const_iterator _iter849;
+ for (_iter849 = (*(this->foreignKeys)).begin(); _iter849 != (*(this->foreignKeys)).end(); ++_iter849)
      {
- xfer += (*_iter841).write(oprot);
+ xfer += (*_iter849).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -5641,14 +5641,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size842;
- ::apache::thrift::protocol::TType _etype845;
- xfer += iprot->readListBegin(_etype845, _size842);
- this->success.resize(_size842);
- uint32_t _i846;
- for (_i846 = 0; _i846 < _size842; ++_i846)
+ 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[_i846]);
+ xfer += iprot->readString(this->success[_i854]);
              }
              xfer += iprot->readListEnd();
            }
@@ -5687,10 +5687,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 _iter847;
- for (_iter847 = this->success.begin(); _iter847 != this->success.end(); ++_iter847)
+ std::vector<std::string> ::const_iterator _iter855;
+ for (_iter855 = this->success.begin(); _iter855 != this->success.end(); ++_iter855)
        {
- xfer += oprot->writeString((*_iter847));
+ xfer += oprot->writeString((*_iter855));
        }
        xfer += oprot->writeListEnd();
      }
@@ -5735,14 +5735,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size848;
- ::apache::thrift::protocol::TType _etype851;
- xfer += iprot->readListBegin(_etype851, _size848);
- (*(this->success)).resize(_size848);
- uint32_t _i852;
- for (_i852 = 0; _i852 < _size848; ++_i852)
+ uint32_t _size856;
+ ::apache::thrift::protocol::TType _etype859;
+ xfer += iprot->readListBegin(_etype859, _size856);
+ (*(this->success)).resize(_size856);
+ uint32_t _i860;
+ for (_i860 = 0; _i860 < _size856; ++_i860)
              {
- xfer += iprot->readString((*(this->success))[_i852]);
+ xfer += iprot->readString((*(this->success))[_i860]);
              }
              xfer += iprot->readListEnd();
            }
@@ -5817,14 +5817,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 _size853;
- ::apache::thrift::protocol::TType _etype856;
- xfer += iprot->readListBegin(_etype856, _size853);
- this->tbl_types.resize(_size853);
- uint32_t _i857;
- for (_i857 = 0; _i857 < _size853; ++_i857)
+ uint32_t _size861;
+ ::apache::thrift::protocol::TType _etype864;
+ xfer += iprot->readListBegin(_etype864, _size861);
+ this->tbl_types.resize(_size861);
+ uint32_t _i865;
+ for (_i865 = 0; _i865 < _size861; ++_i865)
              {
- xfer += iprot->readString(this->tbl_types[_i857]);
+ xfer += iprot->readString(this->tbl_types[_i865]);
              }
              xfer += iprot->readListEnd();
            }
@@ -5861,10 +5861,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 _iter858;
- for (_iter858 = this->tbl_types.begin(); _iter858 != this->tbl_types.end(); ++_iter858)
+ std::vector<std::string> ::const_iterator _iter866;
+ for (_iter866 = this->tbl_types.begin(); _iter866 != this->tbl_types.end(); ++_iter866)
      {
- xfer += oprot->writeString((*_iter858));
+ xfer += oprot->writeString((*_iter866));
      }
      xfer += oprot->writeListEnd();
    }
@@ -5896,10 +5896,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 _iter859;
- for (_iter859 = (*(this->tbl_types)).begin(); _iter859 != (*(this->tbl_types)).end(); ++_iter859)
+ std::vector<std::string> ::const_iterator _iter867;
+ for (_iter867 = (*(this->tbl_types)).begin(); _iter867 != (*(this->tbl_types)).end(); ++_iter867)
      {
- xfer += oprot->writeString((*_iter859));
+ xfer += oprot->writeString((*_iter867));
      }
      xfer += oprot->writeListEnd();
    }
@@ -5940,14 +5940,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size860;
- ::apache::thrift::protocol::TType _etype863;
- xfer += iprot->readListBegin(_etype863, _size860);
- this->success.resize(_size860);
- uint32_t _i864;
- for (_i864 = 0; _i864 < _size860; ++_i864)
+ 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[_i864].read(iprot);
+ xfer += this->success[_i872].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -5986,10 +5986,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 _iter865;
- for (_iter865 = this->success.begin(); _iter865 != this->success.end(); ++_iter865)
+ std::vector<TableMeta> ::const_iterator _iter873;
+ for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873)
        {
- xfer += (*_iter865).write(oprot);
+ xfer += (*_iter873).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -6034,14 +6034,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size866;
- ::apache::thrift::protocol::TType _etype869;
- xfer += iprot->readListBegin(_etype869, _size866);
- (*(this->success)).resize(_size866);
- uint32_t _i870;
- for (_i870 = 0; _i870 < _size866; ++_i870)
+ uint32_t _size874;
+ ::apache::thrift::protocol::TType _etype877;
+ xfer += iprot->readListBegin(_etype877, _size874);
+ (*(this->success)).resize(_size874);
+ uint32_t _i878;
+ for (_i878 = 0; _i878 < _size874; ++_i878)
              {
- xfer += (*(this->success))[_i870].read(iprot);
+ xfer += (*(this->success))[_i878].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -6179,14 +6179,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size871;
- ::apache::thrift::protocol::TType _etype874;
- xfer += iprot->readListBegin(_etype874, _size871);
- this->success.resize(_size871);
- uint32_t _i875;
- for (_i875 = 0; _i875 < _size871; ++_i875)
+ 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[_i875]);
+ xfer += iprot->readString(this->success[_i883]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6225,10 +6225,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 _iter876;
- for (_iter876 = this->success.begin(); _iter876 != this->success.end(); ++_iter876)
+ std::vector<std::string> ::const_iterator _iter884;
+ for (_iter884 = this->success.begin(); _iter884 != this->success.end(); ++_iter884)
        {
- xfer += oprot->writeString((*_iter876));
+ xfer += oprot->writeString((*_iter884));
        }
        xfer += oprot->writeListEnd();
      }
@@ -6273,14 +6273,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size877;
- ::apache::thrift::protocol::TType _etype880;
- xfer += iprot->readListBegin(_etype880, _size877);
- (*(this->success)).resize(_size877);
- uint32_t _i881;
- for (_i881 = 0; _i881 < _size877; ++_i881)
+ uint32_t _size885;
+ ::apache::thrift::protocol::TType _etype888;
+ xfer += iprot->readListBegin(_etype888, _size885);
+ (*(this->success)).resize(_size885);
+ uint32_t _i889;
+ for (_i889 = 0; _i889 < _size885; ++_i889)
              {
- xfer += iprot->readString((*(this->success))[_i881]);
+ xfer += iprot->readString((*(this->success))[_i889]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6590,14 +6590,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 _size882;
- ::apache::thrift::protocol::TType _etype885;
- xfer += iprot->readListBegin(_etype885, _size882);
- this->tbl_names.resize(_size882);
- uint32_t _i886;
- for (_i886 = 0; _i886 < _size882; ++_i886)
+ uint32_t _size890;
+ ::apache::thrift::protocol::TType _etype893;
+ xfer += iprot->readListBegin(_etype893, _size890);
+ this->tbl_names.resize(_size890);
+ uint32_t _i894;
+ for (_i894 = 0; _i894 < _size890; ++_i894)
              {
- xfer += iprot->readString(this->tbl_names[_i886]);
+ xfer += iprot->readString(this->tbl_names[_i894]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6630,10 +6630,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 _iter887;
- for (_iter887 = this->tbl_names.begin(); _iter887 != this->tbl_names.end(); ++_iter887)
+ std::vector<std::string> ::const_iterator _iter895;
+ for (_iter895 = this->tbl_names.begin(); _iter895 != this->tbl_names.end(); ++_iter895)
      {
- xfer += oprot->writeString((*_iter887));
+ xfer += oprot->writeString((*_iter895));
      }
      xfer += oprot->writeListEnd();
    }
@@ -6661,10 +6661,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 _iter888;
- for (_iter888 = (*(this->tbl_names)).begin(); _iter888 != (*(this->tbl_names)).end(); ++_iter888)
+ std::vector<std::string> ::const_iterator _iter896;
+ for (_iter896 = (*(this->tbl_names)).begin(); _iter896 != (*(this->tbl_names)).end(); ++_iter896)
      {
- xfer += oprot->writeString((*_iter888));
+ xfer += oprot->writeString((*_iter896));
      }
      xfer += oprot->writeListEnd();
    }
@@ -6705,14 +6705,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 _size889;
- ::apache::thrift::protocol::TType _etype892;
- xfer += iprot->readListBegin(_etype892, _size889);
- this->success.resize(_size889);
- uint32_t _i893;
- for (_i893 = 0; _i893 < _size889; ++_i893)
+ 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[_i893].read(iprot);
+ xfer += this->success[_i901].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -6767,10 +6767,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 _iter894;
- for (_iter894 = this->success.begin(); _iter894 != this->success.end(); ++_iter894)
+ std::vector<Table> ::const_iterator _iter902;
+ for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902)
        {
- xfer += (*_iter894).write(oprot);
+ xfer += (*_iter902).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -6823,14 +6823,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 _size895;
- ::apache::thrift::protocol::TType _etype898;
- xfer += iprot->readListBegin(_etype898, _size895);
- (*(this->success)).resize(_size895);
- uint32_t _i899;
- for (_i899 = 0; _i899 < _size895; ++_i899)
+ uint32_t _size903;
+ ::apache::thrift::protocol::TType _etype906;
+ xfer += iprot->readListBegin(_etype906, _size903);
+ (*(this->success)).resize(_size903);
+ uint32_t _i907;
+ for (_i907 = 0; _i907 < _size903; ++_i907)
              {
- xfer += (*(this->success))[_i899].read(iprot);
+ xfer += (*(this->success))[_i907].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -7016,14 +7016,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 _size900;
- ::apache::thrift::protocol::TType _etype903;
- xfer += iprot->readListBegin(_etype903, _size900);
- this->success.resize(_size900);
- uint32_t _i904;
- for (_i904 = 0; _i904 < _size900; ++_i904)
+ 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[_i904]);
+ xfer += iprot->readString(this->success[_i912]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7078,10 +7078,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 _iter905;
- for (_iter905 = this->success.begin(); _iter905 != this->success.end(); ++_iter905)
+ std::vector<std::string> ::const_iterator _iter913;
+ for (_iter913 = this->success.begin(); _iter913 != this->success.end(); ++_iter913)
        {
- xfer += oprot->writeString((*_iter905));
+ xfer += oprot->writeString((*_iter913));
        }
        xfer += oprot->writeListEnd();
      }
@@ -7134,14 +7134,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 _size906;
- ::apache::thrift::protocol::TType _etype909;
- xfer += iprot->readListBegin(_etype909, _size906);
- (*(this->success)).resize(_size906);
- uint32_t _i910;
- for (_i910 = 0; _i910 < _size906; ++_i910)
+ uint32_t _size914;
+ ::apache::thrift::protocol::TType _etype917;
+ xfer += iprot->readListBegin(_etype917, _size914);
+ (*(this->success)).resize(_size914);
+ uint32_t _i918;
+ for (_i918 = 0; _i918 < _size914; ++_i918)
              {
- xfer += iprot->readString((*(this->success))[_i910]);
+ xfer += iprot->readString((*(this->success))[_i918]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8475,14 +8475,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->new_parts.clear();
- uint32_t _size911;
- ::apache::thrift::protocol::TType _etype914;
- xfer += iprot->readListBegin(_etype914, _size911);
- this->new_parts.resize(_size911);
- uint32_t _i915;
- for (_i915 = 0; _i915 < _size911; ++_i915)
+ uint32_t _size919;
+ ::apache::thrift::protocol::TType _etype922;
+ xfer += iprot->readListBegin(_etype922, _size919);
+ this->new_parts.resize(_size919);
+ uint32_t _i923;
+ for (_i923 = 0; _i923 < _size919; ++_i923)
              {
- xfer += this->new_parts[_i915].read(iprot);
+ xfer += this->new_parts[_i923].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8511,10 +8511,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 _iter916;
- for (_iter916 = this->new_parts.begin(); _iter916 != this->new_parts.end(); ++_iter916)
+ std::vector<Partition> ::const_iterator _iter924;
+ for (_iter924 = this->new_parts.begin(); _iter924 != this->new_parts.end(); ++_iter924)
      {
- xfer += (*_iter916).write(oprot);
+ xfer += (*_iter924).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -8538,10 +8538,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 _iter917;
- for (_iter917 = (*(this->new_parts)).begin(); _iter917 != (*(this->new_parts)).end(); ++_iter917)
+ std::vector<Partition> ::const_iterator _iter925;
+ for (_iter925 = (*(this->new_parts)).begin(); _iter925 != (*(this->new_parts)).end(); ++_iter925)
      {
- xfer += (*_iter917).write(oprot);
+ xfer += (*_iter925).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -8750,14 +8750,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 _size918;
- ::apache::thrift::protocol::TType _etype921;
- xfer += iprot->readListBegin(_etype921, _size918);
- this->new_parts.resize(_size918);
- uint32_t _i922;
- for (_i922 = 0; _i922 < _size918; ++_i922)
+ uint32_t _size926;
+ ::apache::thrift::protocol::TType _etype929;
+ xfer += iprot->readListBegin(_etype929, _size926);
+ this->new_parts.resize(_size926);
+ uint32_t _i930;
+ for (_i930 = 0; _i930 < _size926; ++_i930)
              {
- xfer += this->new_parts[_i922].read(iprot);
+ xfer += this->new_parts[_i930].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8786,10 +8786,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 _iter923;
- for (_iter923 = this->new_parts.begin(); _iter923 != this->new_parts.end(); ++_iter923)
+ std::vector<PartitionSpec> ::const_iterator _iter931;
+ for (_iter931 = this->new_parts.begin(); _iter931 != this->new_parts.end(); ++_iter931)
      {
- xfer += (*_iter923).write(oprot);
+ xfer += (*_iter931).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -8813,10 +8813,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 _iter924;
- for (_iter924 = (*(this->new_parts)).begin(); _iter924 != (*(this->new_parts)).end(); ++_iter924)
+ std::vector<PartitionSpec> ::const_iterator _iter932;
+ for (_iter932 = (*(this->new_parts)).begin(); _iter932 != (*(this->new_parts)).end(); ++_iter932)
      {
- xfer += (*_iter924).write(oprot);
+ xfer += (*_iter932).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -9041,14 +9041,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size925;
- ::apache::thrift::protocol::TType _etype928;
- xfer += iprot->readListBegin(_etype928, _size925);
- this->part_vals.resize(_size925);
- uint32_t _i929;
- for (_i929 = 0; _i929 < _size925; ++_i929)
+ uint32_t _size933;
+ ::apache::thrift::protocol::TType _etype936;
+ xfer += iprot->readListBegin(_etype936, _size933);
+ this->part_vals.resize(_size933);
+ uint32_t _i937;
+ for (_i937 = 0; _i937 < _size933; ++_i937)
              {
- xfer += iprot->readString(this->part_vals[_i929]);
+ xfer += iprot->readString(this->part_vals[_i937]);
              }
              xfer += iprot->readListEnd();
            }
@@ -9085,10 +9085,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 _iter930;
- for (_iter930 = this->part_vals.begin(); _iter930 != this->part_vals.end(); ++_iter930)
+ std::vector<std::string> ::const_iterator _iter938;
+ for (_iter938 = this->part_vals.begin(); _iter938 != this->part_vals.end(); ++_iter938)
      {
- xfer += oprot->writeString((*_iter930));
+ xfer += oprot->writeString((*_iter938));
      }
      xfer += oprot->writeListEnd();
    }
@@ -9120,10 +9120,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 _iter931;
- for (_iter931 = (*(this->part_vals)).begin(); _iter931 != (*(this->part_vals)).end(); ++_iter931)
+ std::vector<std::string> ::const_iterator _iter939;
+ for (_iter939 = (*(this->part_vals)).begin(); _iter939 != (*(this->part_vals)).end(); ++_iter939)
      {
- xfer += oprot->writeString((*_iter931));
+ xfer += oprot->writeString((*_iter939));
      }
      xfer += oprot->writeListEnd();
    }
@@ -9595,14 +9595,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size932;
- ::apache::thrift::protocol::TType _etype935;
- xfer += iprot->readListBegin(_etype935, _size932);
- this->part_vals.resize(_size932);
- uint32_t _i936;
- for (_i936 = 0; _i936 < _size932; ++_i936)
+ uint32_t _size940;
+ ::apache::thrift::protocol::TType _etype943;
+ xfer += iprot->readListBegin(_etype943, _size940);
+ this->part_vals.resize(_size940);
+ uint32_t _i944;
+ for (_i944 = 0; _i944 < _size940; ++_i944)
              {
- xfer += iprot->readString(this->part_vals[_i936]);
+ xfer += iprot->readString(this->part_vals[_i944]);
              }
              xfer += iprot->readListEnd();
            }
@@ -9647,10 +9647,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 _iter937;
- for (_iter937 = this->part_vals.begin(); _iter937 != this->part_vals.end(); ++_iter937)
+ std::vector<std::string> ::const_iterator _iter945;
+ for (_iter945 = this->part_vals.begin(); _iter945 != this->part_vals.end(); ++_iter945)
      {
- xfer += oprot->writeString((*_iter937));
+ xfer += oprot->writeString((*_iter945));
      }
      xfer += oprot->writeListEnd();
    }
@@ -9686,10 +9686,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 _iter938;
- for (_iter938 = (*(this->part_vals)).begin(); _iter938 != (*(this->part_vals)).end(); ++_iter938)
+ std::vector<std::string> ::const_iterator _iter946;
+ for (_iter946 = (*(this->part_vals)).begin(); _iter946 != (*(this->part_vals)).end(); ++_iter946)
      {
- xfer += oprot->writeString((*_iter938));
+ xfer += oprot->writeString((*_iter946));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10492,14 +10492,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size939;
- ::apache::thrift::protocol::TType _etype942;
- xfer += iprot->readListBegin(_etype942, _size939);
- this->part_vals.resize(_size939);
- uint32_t _i943;
- for (_i943 = 0; _i943 < _size939; ++_i943)
+ uint32_t _size947;
+ ::apache::thrift::protocol::TType _etype950;
+ xfer += iprot->readListBegin(_etype950, _size947);
+ this->part_vals.resize(_size947);
+ uint32_t _i951;
+ for (_i951 = 0; _i951 < _size947; ++_i951)
              {
- xfer += iprot->readString(this->part_vals[_i943]);
+ xfer += iprot->readString(this->part_vals[_i951]);
              }
              xfer += iprot->readListEnd();
            }
@@ -10544,10 +10544,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 _iter944;
- for (_iter944 = this->part_vals.begin(); _iter944 != this->part_vals.end(); ++_iter944)
+ std::vector<std::string> ::const_iterator _iter952;
+ for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952)
      {
- xfer += oprot->writeString((*_iter944));
+ xfer += oprot->writeString((*_iter952));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10583,10 +10583,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 _iter945;
- for (_iter945 = (*(this->part_vals)).begin(); _iter945 != (*(this->part_vals)).end(); ++_iter945)
+ std::vector<std::string> ::const_iterator _iter953;
+ for (_iter953 = (*(this->part_vals)).begin(); _iter953 != (*(this->part_vals)).end(); ++_iter953)
      {
- xfer += oprot->writeString((*_iter945));
+ xfer += oprot->writeString((*_iter953));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10795,14 +10795,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size946;
- ::apache::thrift::protocol::TType _etype949;
- xfer += iprot->readListBegin(_etype949, _size946);
- this->part_vals.resize(_size946);
- uint32_t _i950;
- for (_i950 = 0; _i950 < _size946; ++_i950)
+ uint32_t _size954;
+ ::apache::thrift::protocol::TType _etype957;
+ xfer += iprot->readListBegin(_etype957, _size954);
+ this->part_vals.resize(_size954);
+ uint32_t _i958;
+ for (_i958 = 0; _i958 < _size954; ++_i958)
              {
- xfer += iprot->readString(this->part_vals[_i950]);
+ xfer += iprot->readString(this->part_vals[_i958]);
              }
              xfer += iprot->readListEnd();
            }
@@ -10855,10 +10855,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 _iter951;
- for (_iter951 = this->part_vals.begin(); _iter951 != this->part_vals.end(); ++_iter951)
+ std::vector<std::string> ::const_iterator _iter959;
+ for (_iter959 = this->part_vals.begin(); _iter959 != this->part_vals.end(); ++_iter959)
      {
- xfer += oprot->writeString((*_iter951));
+ xfer += oprot->writeString((*_iter959));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10898,10 +10898,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 _iter952;
- for (_iter952 = (*(this->part_vals)).begin(); _iter952 != (*(this->part_vals)).end(); ++_iter952)
+ std::vector<std::string> ::const_iterator _iter960;
+ for (_iter960 = (*(this->part_vals)).begin(); _iter960 != (*(this->part_vals)).end(); ++_iter960)
      {
- xfer += oprot->writeString((*_iter952));
+ xfer += oprot->writeString((*_iter960));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11907,14 +11907,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size953;
- ::apache::thrift::protocol::TType _etype956;
- xfer += iprot->readListBegin(_etype956, _size953);
- this->part_vals.resize(_size953);
- uint32_t _i957;
- for (_i957 = 0; _i957 < _size953; ++_i957)
+ uint32_t _size961;
+ ::apache::thrift::protocol::TType _etype964;
+ xfer += iprot->readListBegin(_etype964, _size961);
+ this->part_vals.resize(_size961);
+ uint32_t _i965;
+ for (_i965 = 0; _i965 < _size961; ++_i965)
              {
- xfer += iprot->readString(this->part_vals[_i957]);
+ xfer += iprot->readString(this->part_vals[_i965]);
              }
              xfer += iprot->readListEnd();
            }
@@ -11951,10 +11951,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 _iter958;
- for (_iter958 = this->part_vals.begin(); _iter958 != this->part_vals.end(); ++_iter958)
+ std::vector<std::string> ::const_iterator _iter966;
+ for (_iter966 = this->part_vals.begin(); _iter966 != this->part_vals.end(); ++_iter966)
      {
- xfer += oprot->writeString((*_iter958));
+ xfer += oprot->writeString((*_iter966));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11986,10 +11986,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 _iter959;
- for (_iter959 = (*(this->part_vals)).begin(); _iter959 != (*(this->part_vals)).end(); ++_iter959)
+ std::vector<std::string> ::const_iterator _iter967;
+ for (_iter967 = (*(this->part_vals)).begin(); _iter967 != (*(this->part_vals)).end(); ++_iter967)
      {
- xfer += oprot->writeString((*_iter959));
+ xfer += oprot->writeString((*_iter967));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12178,17 +12178,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->partitionSpecs.clear();
- uint32_t _size960;
- ::apache::thrift::protocol::TType _ktype961;
- ::apache::thrift::protocol::TType _vtype962;
- xfer += iprot->readMapBegin(_ktype961, _vtype962, _size960);
- uint32_t _i964;
- for (_i964 = 0; _i964 < _size960; ++_i964)
+ uint32_t _size968;
+ ::apache::thrift::protocol::TType _ktype969;
+ ::apache::thrift::protocol::TType _vtype970;
+ xfer += iprot->readMapBegin(_ktype969, _vtype970, _size968);
+ uint32_t _i972;
+ for (_i972 = 0; _i972 < _size968; ++_i972)
              {
- std::string _key965;
- xfer += iprot->readString(_key965);
- std::string& _val966 = this->partitionSpecs[_key965];
- xfer += iprot->readString(_val966);
+ std::string _key973;
+ xfer += iprot->readString(_key973);
+ std::string& _val974 = this->partitionSpecs[_key973];
+ xfer += iprot->readString(_val974);
              }
              xfer += iprot->readMapEnd();
            }
@@ -12249,11 +12249,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr
    xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size()));
- std::map<std::string, std::string> ::const_iterator _iter967;
- for (_iter967 = this->partitionSpecs.begin(); _iter967 != this->partitionSpecs.end(); ++_iter967)
+ std::map<std::string, std::string> ::const_iterator _iter975;
+ for (_iter975 = this->partitionSpecs.begin(); _iter975 != this->partitionSpecs.end(); ++_iter975)
      {
- xfer += oprot->writeString(_iter967->first);
- xfer += oprot->writeString(_iter967->second);
+ xfer += oprot->writeString(_iter975->first);
+ xfer += oprot->writeString(_iter975->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12293,11 +12293,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p
    xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size()));
- std::map<std::string, std::string> ::const_iterator _iter968;
- for (_iter968 = (*(this->partitionSpecs)).begin(); _iter968 != (*(this->partitionSpecs)).end(); ++_iter968)
+ std::map<std::string, std::string> ::const_iterator _iter976;
+ for (_iter976 = (*(this->partitionSpecs)).begin(); _iter976 != (*(this->partitionSpecs)).end(); ++_iter976)
      {
- xfer += oprot->writeString(_iter968->first);
- xfer += oprot->writeString(_iter968->second);
+ xfer += oprot->writeString(_iter976->first);
+ xfer += oprot->writeString(_iter976->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12542,17 +12542,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->partitionSpecs.clear();
- uint32_t _size969;
- ::apache::thrift::protocol::TType _ktype970;
- ::apache::thrift::protocol::TType _vtype971;
- xfer += iprot->readMapBegin(_ktype970, _vtype971, _size969);
- uint32_t _i973;
- for (_i973 = 0; _i973 < _size969; ++_i973)
+ uint32_t _size977;
+ ::apache::thrift::protocol::TType _ktype978;
+ ::apache::thrift::protocol::TType _vtype979;
+ xfer += iprot->readMapBegin(_ktype978, _vtype979, _size977);
+ uint32_t _i981;
+ for (_i981 = 0; _i981 < _size977; ++_i981)
              {
- std::string _key974;
- xfer += iprot->readString(_key974);
- std::string& _val975 = this->partitionSpecs[_key974];
- xfer += iprot->readString(_val975);
+ std::string _key982;
+ xfer += iprot->readString(_key982);
+ std::string& _val983 = this->partitionSpecs[_key982];
+ xfer += iprot->readString(_val983);
              }
              xfer += iprot->readMapEnd();
            }
@@ -12613,11 +12613,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p
    xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size()));
- std::map<std::string, std::string> ::const_iterator _iter976;
- for (_iter976 = this->partitionSpecs.begin(); _iter976 != this->partitionSpecs.end(); ++_iter976)
+ std::map<std::string, std::string> ::const_iterator _iter984;
+ for (_iter984 = this->partitionSpecs.begin(); _iter984 != this->partitionSpecs.end(); ++_iter984)
      {
- xfer += oprot->writeString(_iter976->first);
- xfer += oprot->writeString(_iter976->second);
+ xfer += oprot->writeString(_iter984->first);
+ xfer += oprot->writeString(_iter984->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12657,11 +12657,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift::
    xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size()));
- std::map<std::string, std::string> ::const_iterator _iter977;
- for (_iter977 = (*(this->partitionSpecs)).begin(); _iter977 != (*(this->partitionSpecs)).end(); ++_iter977)
+ std::map<std::string, std::string> ::const_iterator _iter985;
+ for (_iter985 = (*(this->partitionSpecs)).begin(); _iter985 != (*(this->partitionSpecs)).end(); ++_iter985)
      {
- xfer += oprot->writeString(_iter977->first);
- xfer += oprot->writeString(_iter977->second);
+ xfer += oprot->writeString(_iter985->first);
+ xfer += oprot->writeString(_iter985->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12718,14 +12718,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size978;
- ::apache::thrift::protocol::TType _etype981;
- xfer += iprot->readListBegin(_etype981, _size978);
- this->success.resize(_size978);
- uint32_t _i982;
- for (_i982 = 0; _i982 < _size978; ++_i982)
+ 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)
              {
- xfer += this->success[_i982].read(iprot);
+ xfer += this->success[_i990].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -12788,10 +12788,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift:
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter983;
- for (_iter983 = this->success.begin(); _iter983 != this->success.end(); ++_iter983)
+ std::vector<Partition> ::const_iterator _iter991;
+ for (_iter991 = this->success.begin(); _iter991 != this->success.end(); ++_iter991)
        {
- xfer += (*_iter983).write(oprot);
+ xfer += (*_iter991).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -12848,14 +12848,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size984;
- ::apache::thrift::protocol::TType _etype987;
- xfer += iprot->readListBegin(_etype987, _size984);
- (*(this->success)).resize(_size984);
- uint32_t _i988;
- for (_i988 = 0; _i988 < _size984; ++_i988)
+ uint32_t _size992;
+ ::apache::thrift::protocol::TType _etype995;
+ xfer += iprot->readListBegin(_etype995, _size992);
+ (*(this->success)).resize(_size992);
+ uint32_t _i996;
+ for (_i996 = 0; _i996 < _size992; ++_i996)
              {
- xfer += (*(this->success))[_i988].read(iprot);
+ xfer += (*(this->success))[_i996].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -12954,14 +12954,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 _size989;
- ::apache::thrift::protocol::TType _etype992;
- xfer += iprot->readListBegin(_etype992, _size989);
- this->part_vals.resize(_size989);
- uint32_t _i993;
- for (_i993 = 0; _i993 < _size989; ++_i993)
+ uint32_t _size997;
+ ::apache::thrift::protocol::TType _etype1000;
+ xfer += iprot->readListBegin(_etype1000, _size997);
+ this->part_vals.resize(_size997);
+ uint32_t _i1001;
+ for (_i1001 = 0; _i1001 < _size997; ++_i1001)
              {
- xfer += iprot->readString(this->part_vals[_i993]);
+ xfer += iprot->readString(this->part_vals[_i1001]);
              }
              xfer += iprot->readListEnd();
            }
@@ -12982,14 +12982,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 _size994;
- ::apache::thrift::protocol::TType _etype997;
- xfer += iprot->readListBegin(_etype997, _size994);
- this->group_names.resize(_size994);
- uint32_t _i998;
- for (_i998 = 0; _i998 < _size994; ++_i998)
+ uint32_t _size1002;
+ ::apache::thrift::protocol::TType _etype1005;
+ xfer += iprot->readListBegin(_etype1005, _size1002);
+ this->group_names.resize(_size1002);
+ uint32_t _i1006;
+ for (_i1006 = 0; _i1006 < _size1002; ++_i1006)
              {
- xfer += iprot->readString(this->group_names[_i998]);
+ xfer += iprot->readString(this->group_names[_i1006]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13026,10 +13026,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter999;
- for (_iter999 = this->part_vals.begin(); _iter999 != this->part_vals.end(); ++_iter999)
+ std::vector<std::string> ::const_iterator _iter1007;
+ for (_iter1007 = this->part_vals.begin(); _iter1007 != this->part_vals.end(); ++_iter1007)
      {
- xfer += oprot->writeString((*_iter999));
+ xfer += oprot->writeString((*_iter1007));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13042,10 +13042,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size()));
- std::vector<std::string> ::const_iterator _iter1000;
- for (_iter1000 = this->group_names.begin(); _iter1000 != this->group_names.end(); ++_iter1000)
+ std::vector<std::string> ::const_iterator _iter1008;
+ for (_iter1008 = this->group_names.begin(); _iter1008 != this->group_names.end(); ++_iter1008)
      {
- xfer += oprot->writeString((*_iter1000));
+ xfer += oprot->writeString((*_iter1008));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13077,10 +13077,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1001;
- for (_iter1001 = (*(this->part_vals)).begin(); _iter1001 != (*(this->part_vals)).end(); ++_iter1001)
+ std::vector<std::string> ::const_iterator _iter1009;
+ for (_iter1009 = (*(this->part_vals)).begin(); _iter1009 != (*(this->part_vals)).end(); ++_iter1009)
      {
- xfer += oprot->writeString((*_iter1001));
+ xfer += oprot->writeString((*_iter1009));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13093,10 +13093,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size()));
- std::vector<std::string> ::const_iterator _iter1002;
- for (_iter1002 = (*(this->group_names)).begin(); _iter1002 != (*(this->group_names)).end(); ++_iter1002)
+ std::vector<std::string> ::const_iterator _iter1010;
+ for (_iter1010 = (*(this->group_names)).begin(); _iter1010 != (*(this->group_names)).end(); ++_iter1010)
      {
- xfer += oprot->writeString((*_iter1002));
+ xfer += oprot->writeString((*_iter1010));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13655,14 +13655,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1003;
- ::apache::thrift::protocol::TType _etype1006;
- xfer += iprot->readListBegin(_etype1006, _size1003);
- this->success.resize(_size1003);
- uint32_t _i1007;
- for (_i1007 = 0; _i1007 < _size1003; ++_i1007)
+ 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)
              {
- xfer += this->success[_i1007].read(iprot);
+ xfer += this->success[_i1015].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13709,10 +13709,10 @@ uint32_t ThriftHiveMetastore_get_partitions_result::write(::apache::thrift::prot
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter1008;
- for (_iter1008 = this->success.begin(); _iter1008 != this->success.end(); ++_iter1008)
+ std::vector<Partition> ::const_iterator _iter1016;
+ for (_iter1016 = this->success.begin(); _iter1016 != this->success.end(); ++_iter1016)
        {
- xfer += (*_iter1008).write(oprot);
+ xfer += (*_iter1016).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -13761,14 +13761,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1009;
- ::apache::thrift::protocol::TType _etype1012;
- xfer += iprot->readListBegin(_etype1012, _size1009);
- (*(this->success)).resize(_size1009);
- uint32_t _i1013;
- for (_i1013 = 0; _i1013 < _size1009; ++_i1013)
+ uint32_t _size1017;
+ ::apache::thrift::protocol::TType _etype1020;
+ xfer += iprot->readListBegin(_etype1020, _size1017);
+ (*(this->success)).resize(_size1017);
+ uint32_t _i1021;
+ for (_i1021 = 0; _i1021 < _size1017; ++_i1021)
              {
- xfer += (*(this->success))[_i1013].read(iprot);
+ xfer += (*(this->success))[_i1021].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13867,14 +13867,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 _size1014;
- ::apache::thrift::protocol::TType _etype1017;
- xfer += iprot->readListBegin(_etype1017, _size1014);
- this->group_names.resize(_size1014);
- uint32_t _i1018;
- for (_i1018 = 0; _i1018 < _size1014; ++_i1018)
+ uint32_t _size1022;
+ ::apache::thrift::protocol::TType _etype1025;
+ xfer += iprot->readListBegin(_etype1025, _size1022);
+ this->group_names.resize(_size1022);
+ uint32_t _i1026;
+ for (_i1026 = 0; _i1026 < _size1022; ++_i1026)
              {
- xfer += iprot->readString(this->group_names[_i1018]);
+ xfer += iprot->readString(this->group_names[_i1026]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13919,10 +13919,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size()));
- std::vector<std::string> ::const_iterator _iter1019;
- for (_iter1019 = this->group_names.begin(); _iter1019 != this->group_names.end(); ++_iter1019)
+ std::vector<std::string> ::const_iterator _iter1027;
+ for (_iter1027 = this->group_names.begin(); _iter1027 != this->group_names.end(); ++_iter1027)
      {
- xfer += oprot->writeString((*_iter1019));
+ xfer += oprot->writeString((*_iter1027));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13962,10 +13962,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size()));
- std::vector<std::string> ::const_iterator _iter1020;
- for (_iter1020 = (*(this->group_names)).begin(); _iter1020 != (*(this->group_names)).end(); ++_iter1020)
+ std::vector<std::string> ::const_iterator _iter1028;
+ for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028)
      {
- xfer += oprot->writeString((*_iter1020));
+ xfer += oprot->writeString((*_iter1028));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14006,14 +14006,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1021;
- ::apache::thrift::protocol::TType _etype1024;
- xfer += iprot->readListBegin(_etype1024, _size1021);
- this->success.resize(_size1021);
- uint32_t _i1025;
- for (_i1025 = 0; _i1025 < _size1021; ++_i1025)
+ uint32_t _size1029;
+ ::apache::thrift::protocol::TType _etype1032;
+ xfer += iprot->readListBegin(_etype1032, _size1029);
+ this->success.resize(_size1029);
+ uint32_t _i1033;
+ for (_i1033 = 0; _i1033 < _size1029; ++_i1033)
              {
- xfer += this->success[_i1025].read(iprot);
+ xfer += this->success[_i1033].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14060,10 +14060,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter1026;
- for (_iter1026 = this->success.begin(); _iter1026 != this->success.end(); ++_iter1026)
+ std::vector<Partition> ::const_iterator _iter1034;
+ for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034)
        {
- xfer += (*_iter1026).write(oprot);
+ xfer += (*_iter1034).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14112,14 +14112,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1027;
- ::apache::thrift::protocol::TType _etype1030;
- xfer += iprot->readListBegin(_etype1030, _size1027);
- (*(this->success)).resize(_size1027);
- uint32_t _i1031;
- for (_i1031 = 0; _i1031 < _size1027; ++_i1031)
+ uint32_t _size1035;
+ ::apache::thrift::protocol::TType _etype1038;
+ xfer += iprot->readListBegin(_etype1038, _size1035);
+ (*(this->success)).resize(_size1035);
+ uint32_t _i1039;
+ for (_i1039 = 0; _i1039 < _size1035; ++_i1039)
              {
- xfer += (*(this->success))[_i1031].read(iprot);
+ xfer += (*(this->success))[_i1039].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14297,14 +14297,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1032;
- ::apache::thrift::protocol::TType _etype1035;
- xfer += iprot->readListBegin(_etype1035, _size1032);
- this->success.resize(_size1032);
- uint32_t _i1036;
- for (_i1036 = 0; _i1036 < _size1032; ++_i1036)
+ 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)
              {
- xfer += this->success[_i1036].read(iprot);
+ xfer += this->success[_i1044].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14351,10 +14351,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<PartitionSpec> ::const_iterator _iter1037;
- for (_iter1037 = this->success.begin(); _iter1037 != this->success.end(); ++_iter1037)
+ std::vector<PartitionSpec> ::const_iterator _iter1045;
+ for (_iter1045 = this->success.begin(); _iter1045 != this->success.end(); ++_iter1045)
        {
- xfer += (*_iter1037).write(oprot);
+ xfer += (*_iter1045).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14403,14 +14403,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1038;
- ::apache::thrift::protocol::TType _etype1041;
- xfer += iprot->readListBegin(_etype1041, _size1038);
- (*(this->success)).resize(_size1038);
- uint32_t _i1042;
- for (_i1042 = 0; _i1042 < _size1038; ++_i1042)
+ uint32_t _size1046;
+ ::apache::thrift::protocol::TType _etype1049;
+ xfer += iprot->readListBegin(_etype1049, _size1046);
+ (*(this->success)).resize(_size1046);
+ uint32_t _i1050;
+ for (_i1050 = 0; _i1050 < _size1046; ++_i1050)
              {
- xfer += (*(this->success))[_i1042].read(iprot);
+ xfer += (*(this->success))[_i1050].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14588,14 +14588,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1043;
- ::apache::thrift::protocol::TType _etype1046;
- xfer += iprot->readListBegin(_etype1046, _size1043);
- this->success.resize(_size1043);
- uint32_t _i1047;
- for (_i1047 = 0; _i1047 < _size1043; ++_i1047)
+ 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)
              {
- xfer += iprot->readString(this->success[_i1047]);
+ xfer += iprot->readString(this->success[_i1055]);
              }
              xfer += iprot->readListEnd();
            }
@@ -14634,10 +14634,10 @@ uint32_t ThriftHiveMetastore_get_part

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 10 of 18 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedMay 9, '16 at 10:31p
activeMay 10, '16 at 6:14p
posts18
users1
websitehive.apache.org

1 user in discussion

Weiz: 18 posts

People

Translate

site design / logo © 2021 Grokbase